AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

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

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

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

@@ -35,35 +118,129 @@
   55     55   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   56     56   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        if let Some(ref val) = self.message {
   58     58   
            ser.write_string(&RESOURCEINUSEEXCEPTION_MEMBER_MESSAGE, val)?;
   59     59   
        }
   60     60   
        Ok(())
   61     61   
    }
   62     62   
}
   63     63   
impl ResourceInUseException {
   64     64   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   65         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   66         -
        deserializer: &mut D,
          65  +
    pub fn deserialize(
          66  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   67     67   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   68     68   
        #[allow(unused_variables, unused_mut)]
   69     69   
        let mut builder = Self::builder();
   70     70   
        #[allow(
   71     71   
            unused_variables,
   72     72   
            unreachable_code,
   73     73   
            clippy::single_match,
   74     74   
            clippy::match_single_binding,
   75     75   
            clippy::diverging_sub_expression
   76     76   
        )]
   77         -
        deserializer.read_struct(&RESOURCEINUSEEXCEPTION_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&RESOURCEINUSEEXCEPTION_SCHEMA, &mut |member, deser| {
   78     78   
            match member.member_index() {
   79     79   
                Some(0) => {
   80     80   
                    builder.message = Some(deser.read_string(member)?);
   81     81   
                }
   82     82   
                _ => {}
   83     83   
            }
   84     84   
            Ok(())
   85     85   
        })?;
   86     86   
        Ok(builder.build())
   87     87   
    }
   88     88   
}
          89  +
impl ResourceInUseException {
          90  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          91  +
    pub fn deserialize_with_response(
          92  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          93  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          94  +
        _status: u16,
          95  +
        _body: &[u8],
          96  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          97  +
        Self::deserialize(deserializer)
          98  +
    }
          99  +
}
   89    100   
impl ResourceInUseException {
   90    101   
    /// Returns the error message.
   91    102   
    pub fn message(&self) -> ::std::option::Option<&str> {
   92    103   
        self.message.as_deref()
   93    104   
    }
   94    105   
}
   95    106   
impl ::std::fmt::Display for ResourceInUseException {
   96    107   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   97    108   
        ::std::write!(f, "ResourceInUseException")?;
   98    109   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/error/_unmodifiable_entity_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/error/_validation_exception.rs

@@ -44,44 +127,138 @@
   64     64   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   65     65   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   66     66   
        if let Some(ref val) = self.message {
   67     67   
            ser.write_string(&VALIDATIONEXCEPTION_MEMBER_MESSAGE, val)?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl ValidationException {
   73     73   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          74  +
    pub fn deserialize(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     76   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        #[allow(unused_variables, unused_mut)]
   78     78   
        let mut builder = Self::builder();
   79     79   
        #[allow(
   80     80   
            unused_variables,
   81     81   
            unreachable_code,
   82     82   
            clippy::single_match,
   83     83   
            clippy::match_single_binding,
   84     84   
            clippy::diverging_sub_expression
   85     85   
        )]
   86         -
        deserializer.read_struct(&VALIDATIONEXCEPTION_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&VALIDATIONEXCEPTION_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.message = Some(deser.read_string(member)?);
   90     90   
                }
   91     91   
                _ => {}
   92     92   
            }
   93     93   
            Ok(())
   94     94   
        })?;
   95     95   
        Ok(builder.build())
   96     96   
    }
   97     97   
}
          98  +
impl ValidationException {
          99  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         100  +
    pub fn deserialize_with_response(
         101  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         102  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         103  +
        _status: u16,
         104  +
        _body: &[u8],
         105  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         106  +
        Self::deserialize(deserializer)
         107  +
    }
         108  +
}
   98    109   
impl ValidationException {
   99    110   
    /// Returns the error message.
  100    111   
    pub fn message(&self) -> ::std::option::Option<&str> {
  101    112   
        self.message.as_deref()
  102    113   
    }
  103    114   
}
  104    115   
impl ::std::fmt::Display for ValidationException {
  105    116   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  106    117   
        ::std::write!(f, "ValidationException")?;
  107    118   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/Cargo.toml

@@ -1,1 +152,152 @@
   14     14   
protocol = "aws.protocols#awsJson1_0"
   15     15   
[package.metadata.docs.rs]
   16     16   
all-features = true
   17     17   
targets = ["x86_64-unknown-linux-gnu"]
   18     18   
[dependencies.aws-credential-types]
   19     19   
path = "../aws-credential-types"
   20     20   
version = "1.2.14"
   21     21   
   22     22   
[dependencies.aws-runtime]
   23     23   
path = "../aws-runtime"
   24         -
version = "1.7.3"
          24  +
version = "1.7.4"
   25     25   
   26     26   
[dependencies.aws-smithy-async]
   27     27   
path = "../aws-smithy-async"
   28     28   
version = "1.2.14"
   29     29   
   30     30   
[dependencies.aws-smithy-http]
   31     31   
path = "../aws-smithy-http"
   32     32   
version = "0.63.6"
   33     33   
   34     34   
[dependencies.aws-smithy-json]
   35     35   
path = "../aws-smithy-json"
   36     36   
version = "0.62.6"
   37     37   
   38     38   
[dependencies.aws-smithy-observability]
   39     39   
path = "../aws-smithy-observability"
   40     40   
version = "0.2.6"
   41     41   
   42     42   
[dependencies.aws-smithy-runtime]
   43     43   
path = "../aws-smithy-runtime"
   44     44   
features = ["client"]
   45         -
version = "1.10.3"
          45  +
version = "1.10.4"
   46     46   
   47     47   
[dependencies.aws-smithy-runtime-api]
   48     48   
path = "../aws-smithy-runtime-api"
   49     49   
features = ["client", "http-1x"]
   50         -
version = "1.11.6"
          50  +
version = "1.11.7"
   51     51   
   52     52   
[dependencies.aws-smithy-schema]
   53     53   
path = "../aws-smithy-schema"
   54     54   
version = "1.0.0"
   55     55   
   56     56   
[dependencies.aws-smithy-types]
   57     57   
path = "../aws-smithy-types"
   58     58   
features = ["http-body-1-x"]
   59     59   
version = "1.4.7"
   60     60   
   61     61   
[dependencies.aws-types]
   62     62   
path = "../aws-types"
   63     63   
version = "1.4.0"
   64     64   
   65     65   
[dependencies.bytes]
   66     66   
version = "1.4.0"
   67     67   
   68     68   
[dependencies.fastrand]
   69     69   
version = "2.0.0"
   70     70   
   71     71   
[dependencies.http]
   72     72   
version = "0.2.9"
   73     73   
   74     74   
[dependencies.http-1x]
   75     75   
version = "1"
   76     76   
package = "http"
   77     77   
   78     78   
[dependencies.regex-lite]
   79     79   
version = "0.1.5"
   80     80   
   81     81   
[dependencies.tracing]
   82     82   
version = "0.1"
   83     83   
[dev-dependencies.approx]
   84     84   
version = "0.5.1"
   85     85   
   86     86   
[dev-dependencies.aws-config]
   87     87   
path = "../aws-config"
   88     88   
version = "1.9.0"
   89     89   
   90     90   
[dev-dependencies.aws-credential-types]
   91     91   
path = "../aws-credential-types"
   92     92   
features = ["test-util"]
   93     93   
version = "1.2.14"
   94     94   
   95     95   
[dev-dependencies.aws-runtime]
   96     96   
path = "../aws-runtime"
   97     97   
features = ["test-util"]
   98         -
version = "1.7.3"
          98  +
version = "1.7.4"
   99     99   
  100    100   
[dev-dependencies.aws-smithy-async]
  101    101   
path = "../aws-smithy-async"
  102    102   
features = ["test-util"]
  103    103   
version = "1.2.14"
  104    104   
  105    105   
[dev-dependencies.aws-smithy-http-client]
  106    106   
path = "../aws-smithy-http-client"
  107    107   
features = ["test-util", "wire-mock"]
  108    108   
version = "1.1.12"
  109    109   
  110    110   
[dev-dependencies.aws-smithy-protocol-test]
  111    111   
path = "../aws-smithy-protocol-test"
  112    112   
version = "0.63.14"
  113    113   
  114    114   
[dev-dependencies.aws-smithy-runtime]
  115    115   
path = "../aws-smithy-runtime"
  116    116   
features = ["test-util"]
  117         -
version = "1.10.3"
         117  +
version = "1.10.4"
  118    118   
  119    119   
[dev-dependencies.aws-smithy-runtime-api]
  120    120   
path = "../aws-smithy-runtime-api"
  121    121   
features = ["test-util"]
  122         -
version = "1.11.6"
         122  +
version = "1.11.7"
  123    123   
  124    124   
[dev-dependencies.aws-smithy-types]
  125    125   
path = "../aws-smithy-types"
  126    126   
features = ["http-body-1-x", "test-util"]
  127    127   
version = "1.4.7"
  128    128   
  129    129   
[dev-dependencies.criterion]
  130    130   
version = "0.5.0"
  131    131   
  132    132   
[dev-dependencies.futures-util]

tmp-codegen-diff/aws-sdk/sdk/dynamodb/benches/deserialization_bench.rs

@@ -1,1 +47,58 @@
    1      1   
/*
    2      2   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    3      3   
 * SPDX-License-Identifier: Apache-2.0
    4      4   
 */
    5      5   
    6      6   
use aws_sdk_dynamodb::operation::query::QueryOutput;
    7      7   
use aws_smithy_runtime_api::client::orchestrator::HttpResponse;
    8      8   
use aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
    9      9   
use aws_smithy_runtime_api::client::ser_de::{DeserializeResponse, SharedResponseDeserializer};
   10     10   
use aws_smithy_types::body::SdkBody;
          11  +
use aws_smithy_types::config_bag::ConfigBag;
   11     12   
use criterion::{criterion_group, criterion_main, Criterion};
   12     13   
   13     14   
fn do_bench() {
   14     15   
    use aws_sdk_dynamodb::operation::query::Query;
   15     16   
    use bytes::Bytes;
   16     17   
   17     18   
    let response = HttpResponse::try_from(http_1x::Response::builder()
   18     19   
        .header("server", "Server")
   19     20   
        .header("date", "Mon, 08 Mar 2021 15:51:23 GMT")
   20     21   
        .header("content-type", "application/x-amz-json-1.0")
   21     22   
        .header("content-length", "1231")
   22     23   
        .header("connection", "keep-alive")
   23     24   
        .header("x-amzn-requestid", "A5FGSJ9ET4OKB8183S9M47RQQBVV4KQNSO5AEMVJF66Q9ASUAAJG")
   24     25   
        .header("x-amz-crc32", "624725176")
   25     26   
        .status(http_1x::StatusCode::from_u16(200).unwrap())
   26     27   
        .body(SdkBody::from(Bytes::copy_from_slice(br#"{"Count":2,"Items":[{"year":{"N":"2013"},"info":{"M":{"actors":{"L":[{"S":"Daniel Bruhl"},{"S":"Chris Hemsworth"},{"S":"Olivia Wilde"}]},"plot":{"S":"A re-creation of the merciless 1970s rivalry between Formula One rivals James Hunt and Niki Lauda."},"release_date":{"S":"2013-09-02T00:00:00Z"},"image_url":{"S":"http://ia.media-imdb.com/images/M/MV5BMTQyMDE0MTY0OV5BMl5BanBnXkFtZTcwMjI2OTI0OQ@@._V1_SX400_.jpg"},"genres":{"L":[{"S":"Action"},{"S":"Biography"},{"S":"Drama"},{"S":"Sport"}]},"directors":{"L":[{"S":"Ron Howard"}]},"rating":{"N":"8.3"},"rank":{"N":"2"},"running_time_secs":{"N":"7380"}}},"title":{"S":"Rush"}},{"year":{"N":"2013"},"info":{"M":{"actors":{"L":[{"S":"David Matthewman"},{"S":"Ann Thomas"},{"S":"Jonathan G. Neff"}]},"release_date":{"S":"2013-01-18T00:00:00Z"},"plot":{"S":"A rock band plays their music at high volumes, annoying the neighbors."},"genres":{"L":[{"S":"Comedy"},{"S":"Drama"}]},"image_url":{"S":"http://ia.media-imdb.com/images/N/O9ERWAU7FS797AJ7LU8HN09AMUP908RLlo5JF90EWR7LJKQ7@@._V1_SX400_.jpg"},"directors":{"L":[{"S":"Alice Smith"},{"S":"Bob Jones"}]},"rating":{"N":"6.2"},"rank":{"N":"11"},"running_time_secs":{"N":"5215"}}},"title":{"S":"Turn It Down, Or Else!"}}],"ScannedCount":2}"#)))
   27     28   
        .unwrap()).unwrap();
   28     29   
   29     30   
    let operation = Query::new();
   30     31   
    let config = operation.config().expect("operation should have config");
   31     32   
    let deserializer = config
   32     33   
        .load::<SharedResponseDeserializer>()
   33     34   
        .expect("operation should set a deserializer");
   34     35   
          36  +
    // Create a config bag with the required SharedClientProtocol
          37  +
    let mut config_bag = ConfigBag::base();
          38  +
    let protocol = aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0(
          39  +
        "DynamoDB_20120810",
          40  +
    );
          41  +
    let shared_protocol = aws_smithy_schema::protocol::SharedClientProtocol::new(protocol);
          42  +
    let mut layer = aws_smithy_types::config_bag::Layer::new("bench");
          43  +
    layer.store_put(shared_protocol);
          44  +
    config_bag.push_shared_layer(layer.freeze());
          45  +
   35     46   
    let output = deserializer
   36         -
        .deserialize_nonstreaming(&response)
          47  +
        .deserialize_nonstreaming_with_config(&response, &config_bag)
   37     48   
        .expect("success");
   38     49   
    let output = output.downcast::<QueryOutput>().expect("correct type");
   39     50   
    assert_eq!(2, output.count);
   40     51   
}
   41     52   
   42     53   
fn bench_group(c: &mut Criterion) {
   43     54   
    c.bench_function("deserialization_bench", |b| b.iter(do_bench));
   44     55   
}
   45     56   
   46     57   
criterion_group!(benches, bench_group);

tmp-codegen-diff/aws-sdk/sdk/dynamodb/benches/serialization_bench.rs

@@ -15,15 +75,85 @@
   35     35   
        )
   36     36   
    };
   37     37   
}
   38     38   
   39     39   
fn do_bench(input: &PutItemInput) {
   40     40   
    let operation = PutItem::new();
   41     41   
    let config = operation.config().expect("operation should have config");
   42     42   
    let serializer = config
   43     43   
        .load::<SharedRequestSerializer>()
   44     44   
        .expect("operation should set a serializer");
          45  +
          46  +
    // Create a config bag with the required SharedClientProtocol
   45     47   
    let mut config_bag = ConfigBag::base();
          48  +
    let protocol = aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0(
          49  +
        "DynamoDB_20120810",
          50  +
    );
          51  +
    let shared_protocol = aws_smithy_schema::protocol::SharedClientProtocol::new(protocol);
          52  +
    let mut layer = aws_smithy_types::config_bag::Layer::new("bench");
          53  +
    layer.store_put(shared_protocol);
          54  +
    config_bag.push_shared_layer(layer.freeze());
          55  +
   46     56   
    let input = Input::erase(input.clone());
   47     57   
   48     58   
    let request = serializer
   49     59   
        .serialize_input(input, &mut config_bag)
   50     60   
        .expect("success");
   51     61   
    let body = request.body().bytes().unwrap();
   52     62   
    assert_eq!(body[0], b'{');
   53     63   
}
   54     64   
   55     65   
fn bench_group(c: &mut Criterion) {

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/config.rs

@@ -23,23 +82,86 @@
   43     43   
            config: self.cloneable.clone(),
   44     44   
            runtime_components: self.runtime_components.clone(),
   45     45   
            runtime_plugins: self.runtime_plugins.clone(),
   46     46   
            behavior_version: self.behavior_version,
   47     47   
        }
   48     48   
    }
   49     49   
    /// Return a reference to the stalled stream protection configuration contained in this config, if any.
   50     50   
    pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
   51     51   
        self.config.load::<crate::config::StalledStreamProtectionConfig>()
   52     52   
    }
          53  +
    /// Returns the client protocol used for serialization and deserialization.
          54  +
    pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
          55  +
        self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
          56  +
    }
   53     57   
    /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
   54     58   
    pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
   55     59   
        self.runtime_components.http_client()
   56     60   
    }
   57     61   
    /// Return the auth schemes configured on this service config
   58     62   
    pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
   59     63   
        self.runtime_components.auth_schemes()
   60     64   
    }
   61     65   
   62     66   
    /// Return the auth scheme resolver configured on this service config
@@ -153,157 +255,278 @@
  173    177   
    ///
  174    178   
    pub fn new() -> Self {
  175    179   
        Self::default()
  176    180   
    }
  177    181   
    /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
  178    182   
    /// but not those in runtime components.
  179    183   
    #[allow(unused)]
  180    184   
    pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
  181    185   
        let mut builder = Self::new();
  182    186   
        builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         187  +
        if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
         188  +
            builder.set_protocol(::std::option::Option::Some(protocol));
         189  +
        }
  183    190   
        builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
  184    191   
        builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
  185    192   
        builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
  186    193   
        builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
  187    194   
        builder.set_app_name(config_bag.load::<::aws_types::app_name::AppName>().cloned());
  188    195   
        builder.set_account_id_endpoint_mode(config_bag.load::<::aws_types::endpoint_config::AccountIdEndpointMode>().cloned());
  189    196   
        builder.set_endpoint_url(config_bag.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()));
  190    197   
        builder.set_use_dual_stack(config_bag.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0));
  191    198   
        builder.set_use_fips(config_bag.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0));
  192    199   
        builder.set_region(config_bag.load::<crate::config::Region>().cloned());
  193    200   
        builder
  194    201   
    }
  195    202   
    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
  196    203   
    /// to configure protection for stalled streams.
  197    204   
    pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
  198    205   
        self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
  199    206   
        self
  200    207   
    }
  201    208   
    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
  202    209   
    /// to configure protection for stalled streams.
  203    210   
    pub fn set_stalled_stream_protection(
  204    211   
        &mut self,
  205    212   
        stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
  206    213   
    ) -> &mut Self {
  207    214   
        self.config.store_or_unset(stalled_stream_protection_config);
  208    215   
        self
  209    216   
    }
  210    217   
    /// Sets the idempotency token provider to use for service calls that require tokens.
  211    218   
    pub fn idempotency_token_provider(
  212    219   
        mut self,
  213    220   
        idempotency_token_provider: impl ::std::convert::Into<crate::idempotency_token::IdempotencyTokenProvider>,
  214    221   
    ) -> Self {
  215    222   
        self.set_idempotency_token_provider(::std::option::Option::Some(idempotency_token_provider.into()));
  216    223   
        self
  217    224   
    }
  218    225   
    /// Sets the idempotency token provider to use for service calls that require tokens.
  219    226   
    pub fn set_idempotency_token_provider(
  220    227   
        &mut self,
  221    228   
        idempotency_token_provider: ::std::option::Option<crate::idempotency_token::IdempotencyTokenProvider>,
  222    229   
    ) -> &mut Self {
  223    230   
        self.config.store_or_unset(idempotency_token_provider);
  224    231   
        self
  225    232   
    }
         233  +
    /// Sets the client protocol to use for serialization and deserialization.
         234  +
    ///
         235  +
    /// This overrides the default protocol determined by the service model,
         236  +
    /// enabling runtime protocol selection.
         237  +
    pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         238  +
        self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
         239  +
            protocol,
         240  +
        )));
         241  +
        self
         242  +
    }
         243  +
         244  +
    /// Sets the client protocol to use for serialization and deserialization.
         245  +
    pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         246  +
        self.config.store_or_unset(protocol);
         247  +
        self
         248  +
    }
  226    249   
    /// Sets the HTTP client to use when making requests.
  227    250   
    ///
  228    251   
    /// # Examples
  229    252   
    /// ```no_run
  230    253   
    /// # #[cfg(test)]
  231    254   
    /// # mod tests {
  232    255   
    /// # #[test]
  233    256   
    /// # fn example() {
  234    257   
    /// use std::time::Duration;
  235    258   
    /// use aws_sdk_dynamodb::config::Config;
@@ -1304,1327 +1363,1391 @@
 1324   1347   
pub(crate) struct ServiceRuntimePlugin {
 1325   1348   
    config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
 1326   1349   
    runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1327   1350   
}
 1328   1351   
 1329   1352   
impl ServiceRuntimePlugin {
 1330   1353   
    pub fn new(_service_config: crate::config::Config) -> Self {
 1331   1354   
        let config = {
 1332   1355   
            let mut cfg = ::aws_smithy_types::config_bag::Layer::new("DynamoDB_20120810");
 1333   1356   
            cfg.store_put(crate::idempotency_token::default_provider());
        1357  +
            if _service_config.protocol().is_none() {
        1358  +
                cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
        1359  +
                    ::aws_smithy_json::protocol::aws_json_rpc::AwsJsonRpcProtocol::aws_json_1_0("DynamoDB_20120810"),
        1360  +
                ));
        1361  +
            }
 1334   1362   
            cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
 1335   1363   
            ::std::option::Option::Some(cfg.freeze())
 1336   1364   
        };
 1337   1365   
        let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
 1338   1366   
        runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
 1339   1367   
            use crate::config::auth::ResolveAuthScheme;
 1340   1368   
            crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
 1341   1369   
        }));
 1342   1370   
        runtime_components.set_endpoint_resolver(::std::option::Option::Some({
 1343   1371   
            use crate::config::endpoint::ResolveEndpoint;
@@ -1441,1469 +1500,1531 @@
 1461   1489   
        builder.set_account_id_endpoint_mode(input.account_id_endpoint_mode().cloned());
 1462   1490   
        // resiliency
 1463   1491   
        builder.set_retry_config(input.retry_config().cloned());
 1464   1492   
        builder.set_timeout_config(input.timeout_config().cloned());
 1465   1493   
        builder.set_sleep_impl(input.sleep_impl());
 1466   1494   
 1467   1495   
        builder.set_http_client(input.http_client());
 1468   1496   
        builder.set_time_source(input.time_source());
 1469   1497   
        builder.set_behavior_version(input.behavior_version());
 1470   1498   
        builder.set_auth_scheme_preference(input.auth_scheme_preference().cloned());
        1499  +
        if let Some(protocol) = input.protocol() {
        1500  +
            builder.set_protocol(Some(protocol.clone()));
        1501  +
        }
 1471   1502   
        // setting `None` here removes the default
 1472   1503   
        if let Some(config) = input.stalled_stream_protection() {
 1473   1504   
            builder.set_stalled_stream_protection(Some(config));
 1474   1505   
        }
 1475   1506   
 1476   1507   
        if let Some(cache) = input.identity_cache() {
 1477   1508   
            builder.set_identity_cache(cache);
 1478   1509   
        }
 1479   1510   
        builder.set_app_name(input.app_name().cloned());
 1480   1511

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/lib.rs

@@ -192,192 +238,234 @@
  212    212   
pub(crate) mod client_idempotency_token;
  213    213   
  214    214   
mod idempotency_token;
  215    215   
  216    216   
mod observability_feature;
  217    217   
  218    218   
pub(crate) mod protocol_serde;
  219    219   
  220    220   
mod sdk_feature_tracker;
  221    221   
  222         -
mod serialization_settings;
  223         -
  224    222   
mod endpoint_lib;
  225    223   
  226         -
mod lens;
         224  +
mod json_errors;
  227    225   
  228         -
mod serde_util;
         226  +
mod lens;
  229    227   
  230    228   
/// Supporting types for waiters.
  231    229   
///
  232    230   
/// Note: to use waiters, import the [`Waiters`](crate::client::Waiters) trait, which adds methods prefixed with `wait_until` to the client.
  233    231   
pub mod waiters;
  234    232   
  235         -
mod json_errors;
  236         -
  237    233   
#[doc(inline)]
  238    234   
pub use client::Client;

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_execute_statement.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `BatchExecuteStatement`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct BatchExecuteStatement;
    6      6   
impl BatchExecuteStatement {
    7      7   
    /// Creates a new `BatchExecuteStatement`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::batch_execute_statement::BatchExecuteStatementInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::batch_execute_statement::BatchExecuteStatementOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::batch_execute_statement::BatchExecuteStatementInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::batch_execute_statement::BatchExecuteStatementOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::batch_execute_statement::BatchExecuteStatementError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +247,334 @@
  138    142   
                crate::operation::batch_execute_statement::BatchExecuteStatementError,
  139    143   
            >::new());
  140    144   
  141    145   
        ::std::borrow::Cow::Owned(rcb)
  142    146   
    }
  143    147   
}
  144    148   
  145    149   
#[derive(Debug)]
  146    150   
struct BatchExecuteStatementResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for BatchExecuteStatementResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         152  +
    fn deserialize_nonstreaming_with_config(
  149    153   
        &self,
  150    154   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         155  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    156   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    157   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153         -
        let headers = response.headers();
  154         -
        let body = response.body().bytes().expect("body loaded");
  155    158   
        #[allow(unused_mut)]
  156    159   
        let mut force_error = false;
  157    160   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158         -
        let parse_result = if !success && status != 200 || force_error {
  159         -
            crate::protocol_serde::shape_batch_execute_statement::de_batch_execute_statement_http_error(status, headers, body)
  160         -
        } else {
  161         -
            crate::protocol_serde::shape_batch_execute_statement::de_batch_execute_statement_http_response(status, headers, body)
         161  +
        if !success && status != 200 || force_error {
         162  +
            let headers = response.headers();
         163  +
            let body = response.body().bytes().expect("body loaded");
         164  +
            #[allow(unused_mut)]
         165  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         166  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         167  +
            })?;
         168  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         169  +
            let generic = generic_builder.build();
         170  +
            let error_code = match generic.code() {
         171  +
                ::std::option::Option::Some(code) => code,
         172  +
                ::std::option::Option::None => {
         173  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         174  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         175  +
                            crate::operation::batch_execute_statement::BatchExecuteStatementError::unhandled(generic),
         176  +
                        ),
         177  +
                    ))
         178  +
                }
  162    179   
            };
  163         -
        crate::protocol_serde::type_erase_result(parse_result)
         180  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         181  +
            let protocol = _cfg
         182  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         183  +
                .expect("a SharedClientProtocol is required");
         184  +
            let err = match error_code {
         185  +
                "InternalServerError" => crate::operation::batch_execute_statement::BatchExecuteStatementError::InternalServerError({
         186  +
                    let mut tmp = match protocol
         187  +
                        .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
         188  +
                        .and_then(|mut deser| {
         189  +
                            crate::types::error::InternalServerError::deserialize_with_response(
         190  +
                                &mut *deser,
         191  +
                                response.headers(),
         192  +
                                response.status().into(),
         193  +
                                body,
         194  +
                            )
         195  +
                        }) {
         196  +
                        ::std::result::Result::Ok(val) => val,
         197  +
                        ::std::result::Result::Err(e) => {
         198  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         199  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         200  +
                            ))
         201  +
                        }
         202  +
                    };
         203  +
                    tmp.meta = generic;
         204  +
                    if tmp.message.is_none() {
         205  +
                        tmp.message = _error_message;
         206  +
                    }
         207  +
                    tmp
         208  +
                }),
         209  +
                "RequestLimitExceeded" => crate::operation::batch_execute_statement::BatchExecuteStatementError::RequestLimitExceeded({
         210  +
                    let mut tmp = match protocol
         211  +
                        .deserialize_response(response, crate::types::error::RequestLimitExceeded::SCHEMA, _cfg)
         212  +
                        .and_then(|mut deser| {
         213  +
                            crate::types::error::RequestLimitExceeded::deserialize_with_response(
         214  +
                                &mut *deser,
         215  +
                                response.headers(),
         216  +
                                response.status().into(),
         217  +
                                body,
         218  +
                            )
         219  +
                        }) {
         220  +
                        ::std::result::Result::Ok(val) => val,
         221  +
                        ::std::result::Result::Err(e) => {
         222  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         223  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         224  +
                            ))
         225  +
                        }
         226  +
                    };
         227  +
                    tmp.meta = generic;
         228  +
                    if tmp.message.is_none() {
         229  +
                        tmp.message = _error_message;
         230  +
                    }
         231  +
                    tmp
         232  +
                }),
         233  +
                "ThrottlingException" => crate::operation::batch_execute_statement::BatchExecuteStatementError::ThrottlingException({
         234  +
                    let mut tmp = match protocol
         235  +
                        .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
         236  +
                        .and_then(|mut deser| {
         237  +
                            crate::types::error::ThrottlingException::deserialize_with_response(
         238  +
                                &mut *deser,
         239  +
                                response.headers(),
         240  +
                                response.status().into(),
         241  +
                                body,
         242  +
                            )
         243  +
                        }) {
         244  +
                        ::std::result::Result::Ok(val) => val,
         245  +
                        ::std::result::Result::Err(e) => {
         246  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         247  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         248  +
                            ))
         249  +
                        }
         250  +
                    };
         251  +
                    tmp.meta = generic;
         252  +
                    if tmp.message.is_none() {
         253  +
                        tmp.message = _error_message;
         254  +
                    }
         255  +
                    tmp
         256  +
                }),
         257  +
                _ => crate::operation::batch_execute_statement::BatchExecuteStatementError::generic(generic),
         258  +
            };
         259  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         260  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         261  +
            ))
         262  +
        } else {
         263  +
            let protocol = _cfg
         264  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         265  +
                .expect("a SharedClientProtocol is required");
         266  +
            let mut deser = protocol
         267  +
                .deserialize_response(response, BatchExecuteStatement::OUTPUT_SCHEMA, _cfg)
         268  +
                .map_err(|e| {
         269  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         270  +
                })?;
         271  +
            let body = response.body().bytes().expect("body loaded");
         272  +
            let output = crate::operation::batch_execute_statement::BatchExecuteStatementOutput::deserialize_with_response(
         273  +
                &mut *deser,
         274  +
                response.headers(),
         275  +
                response.status().into(),
         276  +
                body,
         277  +
            )
         278  +
            .map_err(|e| {
         279  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         280  +
            })?;
         281  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         282  +
        }
  164    283   
    }
  165    284   
}
  166    285   
#[derive(Debug)]
  167    286   
struct BatchExecuteStatementRequestSerializer;
  168    287   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for BatchExecuteStatementRequestSerializer {
  169    288   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  170    289   
    fn serialize_input(
  171    290   
        &self,
  172    291   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  173    292   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  174    293   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  175    294   
        let input = input
  176    295   
            .downcast::<crate::operation::batch_execute_statement::BatchExecuteStatementInput>()
  177    296   
            .expect("correct type");
  178         -
        let _header_serialization_settings = _cfg
  179         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  180         -
            .cloned()
  181         -
            .unwrap_or_default();
  182         -
        let mut request_builder = {
  183         -
            #[allow(clippy::uninlined_format_args)]
  184         -
            fn uri_base(
  185         -
                _input: &crate::operation::batch_execute_statement::BatchExecuteStatementInput,
  186         -
                output: &mut ::std::string::String,
  187         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188         -
                use ::std::fmt::Write as _;
  189         -
                ::std::write!(output, "/").expect("formatting should succeed");
  190         -
                ::std::result::Result::Ok(())
  191         -
            }
  192         -
            #[allow(clippy::unnecessary_wraps)]
  193         -
            fn update_http_builder(
  194         -
                input: &crate::operation::batch_execute_statement::BatchExecuteStatementInput,
  195         -
                builder: ::http_1x::request::Builder,
  196         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197         -
                let mut uri = ::std::string::String::new();
  198         -
                uri_base(input, &mut uri)?;
  199         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200         -
            }
  201         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
  203         -
            builder = _header_serialization_settings.set_default_header(
  204         -
                builder,
  205         -
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206         -
                "DynamoDB_20120810.BatchExecuteStatement",
  207         -
            );
  208         -
            builder
  209         -
        };
  210         -
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_batch_execute_statement::ser_batch_execute_statement_input(
  211         -
            &input,
  212         -
        )?);
  213         -
        if let Some(content_length) = body.content_length() {
  214         -
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  216         -
        }
  217         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         297  +
        let protocol = _cfg
         298  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         299  +
            .expect("a SharedClientProtocol is required");
         300  +
        let mut request = protocol
         301  +
            .serialize_request(&input, BatchExecuteStatement::INPUT_SCHEMA, "", _cfg)
         302  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         303  +
         304  +
        return ::std::result::Result::Ok(request);
  218    305   
    }
  219    306   
}
  220    307   
#[derive(Debug)]
  221    308   
struct BatchExecuteStatementEndpointParamsInterceptor;
  222    309   
  223    310   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for BatchExecuteStatementEndpointParamsInterceptor {
  224    311   
    fn name(&self) -> &'static str {
  225    312   
        "BatchExecuteStatementEndpointParamsInterceptor"
  226    313   
    }
  227    314

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_execute_statement/_batch_execute_statement_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_execute_statement/_batch_execute_statement_output.rs

@@ -8,8 +163,219 @@
   28     28   
    "com.amazonaws.dynamodb.synthetic",
   29     29   
    "BatchExecuteStatementOutput",
   30     30   
);
   31     31   
static BATCHEXECUTESTATEMENTOUTPUT_MEMBER_RESPONSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static(
   33     33   
        "com.amazonaws.dynamodb.synthetic#BatchExecuteStatementOutput$Responses",
   34     34   
        "com.amazonaws.dynamodb.synthetic",
   35     35   
        "BatchExecuteStatementOutput",
   36     36   
    ),
   37     37   
    ::aws_smithy_schema::ShapeType::List,
   38         -
    "responses",
          38  +
    "Responses",
   39     39   
    0,
   40     40   
);
   41     41   
static BATCHEXECUTESTATEMENTOUTPUT_MEMBER_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   42     42   
    ::aws_smithy_schema::ShapeId::from_static(
   43     43   
        "com.amazonaws.dynamodb.synthetic#BatchExecuteStatementOutput$ConsumedCapacity",
   44     44   
        "com.amazonaws.dynamodb.synthetic",
   45     45   
        "BatchExecuteStatementOutput",
   46     46   
    ),
   47     47   
    ::aws_smithy_schema::ShapeType::List,
   48         -
    "consumed_capacity",
          48  +
    "ConsumedCapacity",
   49     49   
    1,
   50     50   
);
          51  +
static BATCHEXECUTESTATEMENTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          52  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          53  +
    ::aws_smithy_schema::ShapeType::String,
          54  +
    "request_id",
          55  +
    2,
          56  +
)
          57  +
.with_http_header("x-amzn-requestid");
   51     58   
static BATCHEXECUTESTATEMENTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     59   
    BATCHEXECUTESTATEMENTOUTPUT_SCHEMA_ID,
   53     60   
    ::aws_smithy_schema::ShapeType::Structure,
   54     61   
    &[
   55     62   
        &BATCHEXECUTESTATEMENTOUTPUT_MEMBER_RESPONSES,
   56     63   
        &BATCHEXECUTESTATEMENTOUTPUT_MEMBER_CONSUMED_CAPACITY,
          64  +
        &BATCHEXECUTESTATEMENTOUTPUT_MEMBER__REQUEST_ID,
   57     65   
    ],
   58     66   
);
   59     67   
impl BatchExecuteStatementOutput {
   60     68   
    /// The schema for this shape.
   61     69   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BATCHEXECUTESTATEMENTOUTPUT_SCHEMA;
   62     70   
}
   63     71   
impl ::aws_smithy_schema::serde::SerializableStruct for BatchExecuteStatementOutput {
   64     72   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   65     73   
    fn serialize_members(
   66     74   
        &self,
   67     75   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   68     76   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   69     77   
        if let Some(ref val) = self.responses {
   70     78   
            ser.write_list(
   71     79   
                &BATCHEXECUTESTATEMENTOUTPUT_MEMBER_RESPONSES,
   72     80   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   73     81   
                    for item in val {
   74     82   
                        ser.write_struct(crate::types::BatchStatementResponse::SCHEMA, item)?;
   75     83   
                    }
   76     84   
                    Ok(())
   77     85   
                },
   78     86   
            )?;
   79     87   
        }
   80     88   
        if let Some(ref val) = self.consumed_capacity {
   81     89   
            ser.write_list(
   82     90   
                &BATCHEXECUTESTATEMENTOUTPUT_MEMBER_CONSUMED_CAPACITY,
   83     91   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   84     92   
                    for item in val {
   85     93   
                        ser.write_struct(crate::types::ConsumedCapacity::SCHEMA, item)?;
   86     94   
                    }
   87     95   
                    Ok(())
   88     96   
                },
   89     97   
            )?;
   90     98   
        }
   91     99   
        Ok(())
   92    100   
    }
   93    101   
}
   94    102   
impl BatchExecuteStatementOutput {
   95    103   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   96         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   97         -
        deserializer: &mut D,
         104  +
    pub fn deserialize(
         105  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   98    106   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   99    107   
        #[allow(unused_variables, unused_mut)]
  100    108   
        let mut builder = Self::builder();
  101    109   
        #[allow(
  102    110   
            unused_variables,
  103    111   
            unreachable_code,
  104    112   
            clippy::single_match,
  105    113   
            clippy::match_single_binding,
  106    114   
            clippy::diverging_sub_expression
  107    115   
        )]
  108         -
        deserializer.read_struct(&BATCHEXECUTESTATEMENTOUTPUT_SCHEMA, (), |_, member, deser| {
         116  +
        deserializer.read_struct(&BATCHEXECUTESTATEMENTOUTPUT_SCHEMA, &mut |member, deser| {
  109    117   
            match member.member_index() {
  110    118   
                Some(0) => {
  111    119   
                    builder.responses = Some({
  112         -
                        let container = if let Some(cap) = deser.container_size() {
  113         -
                            Vec::with_capacity(cap)
  114         -
                        } else {
  115         -
                            Vec::new()
  116         -
                        };
  117         -
                        deser.read_list(member, container, |mut list, deser| {
  118         -
                            list.push(crate::types::BatchStatementResponse::deserialize(deser)?);
  119         -
                            Ok(list)
  120         -
                        })?
         120  +
                        let mut container = Vec::new();
         121  +
                        deser.read_list(member, &mut |deser| {
         122  +
                            container.push(crate::types::BatchStatementResponse::deserialize(deser)?);
         123  +
                            Ok(())
         124  +
                        })?;
         125  +
                        container
  121    126   
                    });
  122    127   
                }
  123    128   
                Some(1) => {
  124    129   
                    builder.consumed_capacity = Some({
  125         -
                        let container = if let Some(cap) = deser.container_size() {
  126         -
                            Vec::with_capacity(cap)
  127         -
                        } else {
  128         -
                            Vec::new()
  129         -
                        };
  130         -
                        deser.read_list(member, container, |mut list, deser| {
  131         -
                            list.push(crate::types::ConsumedCapacity::deserialize(deser)?);
  132         -
                            Ok(list)
  133         -
                        })?
         130  +
                        let mut container = Vec::new();
         131  +
                        deser.read_list(member, &mut |deser| {
         132  +
                            container.push(crate::types::ConsumedCapacity::deserialize(deser)?);
         133  +
                            Ok(())
         134  +
                        })?;
         135  +
                        container
         136  +
                    });
         137  +
                }
         138  +
                Some(2) => {
         139  +
                    builder._request_id = Some(deser.read_string(member)?);
         140  +
                }
         141  +
                _ => {}
         142  +
            }
         143  +
            Ok(())
         144  +
        })?;
         145  +
        Ok(builder.build())
         146  +
    }
         147  +
}
         148  +
impl BatchExecuteStatementOutput {
         149  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         150  +
    /// Header-bound members are read directly from headers, avoiding runtime
         151  +
    /// member iteration overhead. Body members are read via the deserializer.
         152  +
    pub fn deserialize_with_response(
         153  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         154  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         155  +
        _status: u16,
         156  +
        _body: &[u8],
         157  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         158  +
        #[allow(unused_variables, unused_mut)]
         159  +
        let mut builder = Self::builder();
         160  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         161  +
            builder._request_id = Some(val.to_string());
         162  +
        }
         163  +
        #[allow(
         164  +
            unused_variables,
         165  +
            unreachable_code,
         166  +
            clippy::single_match,
         167  +
            clippy::match_single_binding,
         168  +
            clippy::diverging_sub_expression
         169  +
        )]
         170  +
        deserializer.read_struct(&BATCHEXECUTESTATEMENTOUTPUT_SCHEMA, &mut |member, deser| {
         171  +
            match member.member_index() {
         172  +
                Some(0) => {
         173  +
                    builder.responses = Some({
         174  +
                        let mut container = Vec::new();
         175  +
                        deser.read_list(member, &mut |deser| {
         176  +
                            container.push(crate::types::BatchStatementResponse::deserialize(deser)?);
         177  +
                            Ok(())
         178  +
                        })?;
         179  +
                        container
         180  +
                    });
         181  +
                }
         182  +
                Some(1) => {
         183  +
                    builder.consumed_capacity = Some({
         184  +
                        let mut container = Vec::new();
         185  +
                        deser.read_list(member, &mut |deser| {
         186  +
                            container.push(crate::types::ConsumedCapacity::deserialize(deser)?);
         187  +
                            Ok(())
         188  +
                        })?;
         189  +
                        container
  134    190   
                    });
  135    191   
                }
  136    192   
                _ => {}
  137    193   
            }
  138    194   
            Ok(())
  139    195   
        })?;
  140    196   
        Ok(builder.build())
  141    197   
    }
  142    198   
}
  143    199   
impl ::aws_types::request_id::RequestId for BatchExecuteStatementOutput {