AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_incorrect_key_material_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(&INCORRECTKEYMATERIALEXCEPTION_MEMBER_MESSAGE, val)?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl IncorrectKeyMaterialException {
   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(&INCORRECTKEYMATERIALEXCEPTION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&INCORRECTKEYMATERIALEXCEPTION_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 IncorrectKeyMaterialException {
          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 IncorrectKeyMaterialException {
   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 IncorrectKeyMaterialException {
   89    100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   90    101   
        ::std::write!(f, "IncorrectKeyMaterialException")?;
   91    102   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_incorrect_trust_anchor_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_invalid_alias_name_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(&INVALIDALIASNAMEEXCEPTION_MEMBER_MESSAGE, val)?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl InvalidAliasNameException {
   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(&INVALIDALIASNAMEEXCEPTION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&INVALIDALIASNAMEEXCEPTION_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 InvalidAliasNameException {
          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 InvalidAliasNameException {
   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 InvalidAliasNameException {
   89    100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   90    101   
        ::std::write!(f, "InvalidAliasNameException")?;
   91    102   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_invalid_arn_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_invalid_ciphertext_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_invalid_grant_id_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(&INVALIDGRANTIDEXCEPTION_MEMBER_MESSAGE, val)?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl InvalidGrantIdException {
   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(&INVALIDGRANTIDEXCEPTION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&INVALIDGRANTIDEXCEPTION_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 InvalidGrantIdException {
          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 InvalidGrantIdException {
   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 InvalidGrantIdException {
   89    100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   90    101   
        ::std::write!(f, "InvalidGrantIdException")?;
   91    102   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_invalid_grant_token_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(&INVALIDGRANTTOKENEXCEPTION_MEMBER_MESSAGE, val)?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl InvalidGrantTokenException {
   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(&INVALIDGRANTTOKENEXCEPTION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&INVALIDGRANTTOKENEXCEPTION_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 InvalidGrantTokenException {
          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 InvalidGrantTokenException {
   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 InvalidGrantTokenException {
   89    100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   90    101   
        ::std::write!(f, "InvalidGrantTokenException")?;
   91    102   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_invalid_import_token_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(&INVALIDIMPORTTOKENEXCEPTION_MEMBER_MESSAGE, val)?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl InvalidImportTokenException {
   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(&INVALIDIMPORTTOKENEXCEPTION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&INVALIDIMPORTTOKENEXCEPTION_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 InvalidImportTokenException {
          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 InvalidImportTokenException {
   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 InvalidImportTokenException {
   89    100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   90    101   
        ::std::write!(f, "InvalidImportTokenException")?;
   91    102   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_invalid_key_usage_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_invalid_marker_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_key_unavailable_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(&KEYUNAVAILABLEEXCEPTION_MEMBER_MESSAGE, val)?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl KeyUnavailableException {
   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(&KEYUNAVAILABLEEXCEPTION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&KEYUNAVAILABLEEXCEPTION_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 KeyUnavailableException {
          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 KeyUnavailableException {
   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 KeyUnavailableException {
   89    100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   90    101   
        ::std::write!(f, "KeyUnavailableException")?;
   91    102   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_kms_internal_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_kms_invalid_mac_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_kms_invalid_signature_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(&KMSINVALIDSIGNATUREEXCEPTION_MEMBER_MESSAGE, val)?;
   52     52   
        }
   53     53   
        Ok(())
   54     54   
    }
   55     55   
}
   56     56   
impl KmsInvalidSignatureException {
   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(&KMSINVALIDSIGNATUREEXCEPTION_SCHEMA, (), |_, member, deser| {
          70  +
        deserializer.read_struct(&KMSINVALIDSIGNATUREEXCEPTION_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 KmsInvalidSignatureException {
          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 KmsInvalidSignatureException {
   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 KmsInvalidSignatureException {
   89    100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   90    101   
        ::std::write!(f, "KmsInvalidSignatureException [KMSInvalidSignatureException]")?;
   91    102   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_kms_invalid_state_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/kms/src/types/error/_limit_exceeded_exception.rs

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