AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_expired_token_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_internal_server_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_invalid_client_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_invalid_client_metadata_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_invalid_grant_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_invalid_redirect_uri_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_invalid_request_exception.rs

@@ -43,43 +175,186 @@
   63     63   
    "error_description",
   64     64   
    2,
   65     65   
);
   66     66   
static INVALIDREQUESTEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.ssooidc#InvalidRequestException$Message",
   69     69   
        "com.amazonaws.ssooidc",
   70     70   
        "InvalidRequestException",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::String,
   73         -
    "message",
          73  +
    "Message",
   74     74   
    3,
   75     75   
);
   76     76   
static INVALIDREQUESTEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   77     77   
    INVALIDREQUESTEXCEPTION_SCHEMA_ID,
   78     78   
    ::aws_smithy_schema::ShapeType::Structure,
   79     79   
    &[
   80     80   
        &INVALIDREQUESTEXCEPTION_MEMBER_ERROR,
   81     81   
        &INVALIDREQUESTEXCEPTION_MEMBER_REASON,
   82     82   
        &INVALIDREQUESTEXCEPTION_MEMBER_ERROR_DESCRIPTION,
   83     83   
        &INVALIDREQUESTEXCEPTION_MEMBER_MESSAGE,
   84     84   
    ],
   85     85   
);
   86     86   
impl InvalidRequestException {
   87     87   
    /// The schema for this shape.
   88     88   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDREQUESTEXCEPTION_SCHEMA;
   89     89   
}
   90     90   
impl ::aws_smithy_schema::serde::SerializableStruct for InvalidRequestException {
   91     91   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   92     92   
    fn serialize_members(
   93     93   
        &self,
   94     94   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   95     95   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   96     96   
        if let Some(ref val) = self.error {
   97     97   
            ser.write_string(&INVALIDREQUESTEXCEPTION_MEMBER_ERROR, val)?;
   98     98   
        }
   99     99   
        if let Some(ref val) = self.reason {
  100    100   
            ser.write_string(&INVALIDREQUESTEXCEPTION_MEMBER_REASON, val.as_str())?;
  101    101   
        }
  102    102   
        if let Some(ref val) = self.error_description {
  103    103   
            ser.write_string(&INVALIDREQUESTEXCEPTION_MEMBER_ERROR_DESCRIPTION, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.message {
  106    106   
            ser.write_string(&INVALIDREQUESTEXCEPTION_MEMBER_MESSAGE, val)?;
  107    107   
        }
  108    108   
        Ok(())
  109    109   
    }
  110    110   
}
  111    111   
impl InvalidRequestException {
  112    112   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  113         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  114         -
        deserializer: &mut D,
         113  +
    pub fn deserialize(
         114  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  115    115   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  116    116   
        #[allow(unused_variables, unused_mut)]
  117    117   
        let mut builder = Self::builder();
  118    118   
        #[allow(
  119    119   
            unused_variables,
  120    120   
            unreachable_code,
  121    121   
            clippy::single_match,
  122    122   
            clippy::match_single_binding,
  123    123   
            clippy::diverging_sub_expression
  124    124   
        )]
  125         -
        deserializer.read_struct(&INVALIDREQUESTEXCEPTION_SCHEMA, (), |_, member, deser| {
         125  +
        deserializer.read_struct(&INVALIDREQUESTEXCEPTION_SCHEMA, &mut |member, deser| {
  126    126   
            match member.member_index() {
  127    127   
                Some(0) => {
  128    128   
                    builder.error = Some(deser.read_string(member)?);
  129    129   
                }
  130    130   
                Some(1) => {
  131    131   
                    builder.reason = Some(crate::types::InvalidRequestExceptionReason::from(deser.read_string(member)?.as_str()));
  132    132   
                }
  133    133   
                Some(2) => {
  134    134   
                    builder.error_description = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(3) => {
  137    137   
                    builder.message = Some(deser.read_string(member)?);
  138    138   
                }
  139    139   
                _ => {}
  140    140   
            }
  141    141   
            Ok(())
  142    142   
        })?;
  143    143   
        Ok(builder.build())
  144    144   
    }
  145    145   
}
         146  +
impl InvalidRequestException {
         147  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         148  +
    pub fn deserialize_with_response(
         149  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         150  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         151  +
        _status: u16,
         152  +
        _body: &[u8],
         153  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         154  +
        Self::deserialize(deserializer)
         155  +
    }
         156  +
}
  146    157   
impl InvalidRequestException {
  147    158   
    /// Returns the error message.
  148    159   
    pub fn message(&self) -> ::std::option::Option<&str> {
  149    160   
        self.message.as_deref()
  150    161   
    }
  151    162   
}
  152    163   
impl ::std::fmt::Display for InvalidRequestException {
  153    164   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  154    165   
        ::std::write!(f, "InvalidRequestException")?;
  155    166   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_invalid_request_region_exception.rs

@@ -59,59 +198,209 @@
   79     79   
    "region",
   80     80   
    3,
   81     81   
);
   82     82   
static INVALIDREQUESTREGIONEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.ssooidc#InvalidRequestRegionException$Message",
   85     85   
        "com.amazonaws.ssooidc",
   86     86   
        "InvalidRequestRegionException",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "message",
          89  +
    "Message",
   90     90   
    4,
   91     91   
);
   92     92   
static INVALIDREQUESTREGIONEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   93     93   
    INVALIDREQUESTREGIONEXCEPTION_SCHEMA_ID,
   94     94   
    ::aws_smithy_schema::ShapeType::Structure,
   95     95   
    &[
   96     96   
        &INVALIDREQUESTREGIONEXCEPTION_MEMBER_ERROR,
   97     97   
        &INVALIDREQUESTREGIONEXCEPTION_MEMBER_ERROR_DESCRIPTION,
   98     98   
        &INVALIDREQUESTREGIONEXCEPTION_MEMBER_ENDPOINT,
   99     99   
        &INVALIDREQUESTREGIONEXCEPTION_MEMBER_REGION,
  100    100   
        &INVALIDREQUESTREGIONEXCEPTION_MEMBER_MESSAGE,
  101    101   
    ],
  102    102   
);
  103    103   
impl InvalidRequestRegionException {
  104    104   
    /// The schema for this shape.
  105    105   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDREQUESTREGIONEXCEPTION_SCHEMA;
  106    106   
}
  107    107   
impl ::aws_smithy_schema::serde::SerializableStruct for InvalidRequestRegionException {
  108    108   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  109    109   
    fn serialize_members(
  110    110   
        &self,
  111    111   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  112    112   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  113    113   
        if let Some(ref val) = self.error {
  114    114   
            ser.write_string(&INVALIDREQUESTREGIONEXCEPTION_MEMBER_ERROR, val)?;
  115    115   
        }
  116    116   
        if let Some(ref val) = self.error_description {
  117    117   
            ser.write_string(&INVALIDREQUESTREGIONEXCEPTION_MEMBER_ERROR_DESCRIPTION, val)?;
  118    118   
        }
  119    119   
        if let Some(ref val) = self.endpoint {
  120    120   
            ser.write_string(&INVALIDREQUESTREGIONEXCEPTION_MEMBER_ENDPOINT, val)?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.region {
  123    123   
            ser.write_string(&INVALIDREQUESTREGIONEXCEPTION_MEMBER_REGION, val)?;
  124    124   
        }
  125    125   
        if let Some(ref val) = self.message {
  126    126   
            ser.write_string(&INVALIDREQUESTREGIONEXCEPTION_MEMBER_MESSAGE, val)?;
  127    127   
        }
  128    128   
        Ok(())
  129    129   
    }
  130    130   
}
  131    131   
impl InvalidRequestRegionException {
  132    132   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  133         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  134         -
        deserializer: &mut D,
         133  +
    pub fn deserialize(
         134  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  135    135   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  136    136   
        #[allow(unused_variables, unused_mut)]
  137    137   
        let mut builder = Self::builder();
  138    138   
        #[allow(
  139    139   
            unused_variables,
  140    140   
            unreachable_code,
  141    141   
            clippy::single_match,
  142    142   
            clippy::match_single_binding,
  143    143   
            clippy::diverging_sub_expression
  144    144   
        )]
  145         -
        deserializer.read_struct(&INVALIDREQUESTREGIONEXCEPTION_SCHEMA, (), |_, member, deser| {
         145  +
        deserializer.read_struct(&INVALIDREQUESTREGIONEXCEPTION_SCHEMA, &mut |member, deser| {
  146    146   
            match member.member_index() {
  147    147   
                Some(0) => {
  148    148   
                    builder.error = Some(deser.read_string(member)?);
  149    149   
                }
  150    150   
                Some(1) => {
  151    151   
                    builder.error_description = Some(deser.read_string(member)?);
  152    152   
                }
  153    153   
                Some(2) => {
  154    154   
                    builder.endpoint = Some(deser.read_string(member)?);
  155    155   
                }
  156    156   
                Some(3) => {
  157    157   
                    builder.region = Some(deser.read_string(member)?);
  158    158   
                }
  159    159   
                Some(4) => {
  160    160   
                    builder.message = Some(deser.read_string(member)?);
  161    161   
                }
  162    162   
                _ => {}
  163    163   
            }
  164    164   
            Ok(())
  165    165   
        })?;
  166    166   
        Ok(builder.build())
  167    167   
    }
  168    168   
}
         169  +
impl InvalidRequestRegionException {
         170  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         171  +
    pub fn deserialize_with_response(
         172  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         173  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         174  +
        _status: u16,
         175  +
        _body: &[u8],
         176  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         177  +
        Self::deserialize(deserializer)
         178  +
    }
         179  +
}
  169    180   
impl InvalidRequestRegionException {
  170    181   
    /// Returns the error message.
  171    182   
    pub fn message(&self) -> ::std::option::Option<&str> {
  172    183   
        self.message.as_deref()
  173    184   
    }
  174    185   
}
  175    186   
impl ::std::fmt::Display for InvalidRequestRegionException {
  176    187   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  177    188   
        ::std::write!(f, "InvalidRequestRegionException")?;
  178    189   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_invalid_scope_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_slow_down_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_unauthorized_client_exception.rs

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

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/types/error/_unsupported_grant_type_exception.rs

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

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

@@ -1,1 +150,150 @@
   14     14   
protocol = "aws.protocols#awsQuery"
   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-query]
   43     43   
path = "../aws-smithy-query"
   44     44   
version = "0.60.15"
   45     45   
   46     46   
[dependencies.aws-smithy-runtime]
   47     47   
path = "../aws-smithy-runtime"
   48     48   
features = ["client"]
   49         -
version = "1.10.3"
          49  +
version = "1.10.4"
   50     50   
   51     51   
[dependencies.aws-smithy-runtime-api]
   52     52   
path = "../aws-smithy-runtime-api"
   53     53   
features = ["client", "http-1x"]
   54         -
version = "1.11.6"
          54  +
version = "1.11.7"
   55     55   
   56     56   
[dependencies.aws-smithy-schema]
   57     57   
path = "../aws-smithy-schema"
   58     58   
version = "1.0.0"
   59     59   
   60     60   
[dependencies.aws-smithy-types]
   61     61   
path = "../aws-smithy-types"
   62     62   
features = ["http-body-1-x"]
   63     63   
version = "1.4.7"
   64     64   
   65     65   
[dependencies.aws-smithy-xml]
   66     66   
path = "../aws-smithy-xml"
   67     67   
version = "0.60.15"
   68     68   
   69     69   
[dependencies.aws-types]
   70     70   
path = "../aws-types"
   71     71   
version = "1.4.0"
   72     72   
   73     73   
[dependencies.fastrand]
   74     74   
version = "2.0.0"
   75     75   
   76     76   
[dependencies.http]
   77     77   
version = "0.2.9"
   78     78   
   79     79   
[dependencies.http-1x]
   80     80   
version = "1"
   81     81   
package = "http"
   82     82   
   83     83   
[dependencies.regex-lite]
   84     84   
version = "0.1.5"
   85     85   
   86     86   
[dependencies.tracing]
   87     87   
version = "0.1"
   88     88   
[dev-dependencies.aws-credential-types]
   89     89   
path = "../aws-credential-types"
   90     90   
features = ["test-util"]
   91     91   
version = "1.2.14"
   92     92   
   93     93   
[dev-dependencies.aws-runtime]
   94     94   
path = "../aws-runtime"
   95     95   
features = ["test-util"]
   96         -
version = "1.7.3"
          96  +
version = "1.7.4"
   97     97   
   98     98   
[dev-dependencies.aws-smithy-async]
   99     99   
path = "../aws-smithy-async"
  100    100   
features = ["test-util"]
  101    101   
version = "1.2.14"
  102    102   
  103    103   
[dev-dependencies.aws-smithy-http-client]
  104    104   
path = "../aws-smithy-http-client"
  105    105   
features = ["test-util", "wire-mock"]
  106    106   
version = "1.1.12"
  107    107   
  108    108   
[dev-dependencies.aws-smithy-protocol-test]
  109    109   
path = "../aws-smithy-protocol-test"
  110    110   
version = "0.63.14"
  111    111   
  112    112   
[dev-dependencies.aws-smithy-runtime]
  113    113   
path = "../aws-smithy-runtime"
  114    114   
features = ["test-util"]
  115         -
version = "1.10.3"
         115  +
version = "1.10.4"
  116    116   
  117    117   
[dev-dependencies.aws-smithy-runtime-api]
  118    118   
path = "../aws-smithy-runtime-api"
  119    119   
features = ["test-util"]
  120         -
version = "1.11.6"
         120  +
version = "1.11.7"
  121    121   
  122    122   
[dev-dependencies.aws-smithy-types]
  123    123   
path = "../aws-smithy-types"
  124    124   
features = ["http-body-1-x", "test-util"]
  125    125   
version = "1.4.7"
  126    126   
  127    127   
[dev-dependencies.futures-util]
  128    128   
version = "0.3.25"
  129    129   
features = ["alloc"]
  130    130   
default-features = false

tmp-codegen-diff/aws-sdk/sdk/sts/src/operation/assume_role.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 `AssumeRole`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct AssumeRole;
    6      6   
impl AssumeRole {
    7      7   
    /// Creates a new `AssumeRole`
    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::assume_role::AssumeRoleInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::assume_role::AssumeRoleOutput::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::assume_role::AssumeRoleInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::assume_role::AssumeRoleOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::assume_role::AssumeRoleError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -116,120 +178,183 @@
  136    140   
                crate::operation::assume_role::AssumeRoleError,
  137    141   
            >::new());
  138    142   
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct AssumeRoleResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for AssumeRoleResponseDeserializer {
  146         -
    fn deserialize_nonstreaming(
         150  +
    fn deserialize_nonstreaming_with_config(
  147    151   
        &self,
  148    152   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         153  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  149    154   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  150    155   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  151    156   
        let headers = response.headers();
  152    157   
        let body = response.body().bytes().expect("body loaded");
  153    158   
        #[allow(unused_mut)]
  154    159   
        let mut force_error = false;
  155    160   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  156    161   
        let parse_result = if !success && status != 200 || force_error {
  157    162   
            crate::protocol_serde::shape_assume_role::de_assume_role_http_error(status, headers, body)
  158    163   
        } else {

tmp-codegen-diff/aws-sdk/sdk/sts/src/operation/assume_role/_assume_role_input.rs

@@ -133,133 +303,303 @@
  153    153   
    "com.amazonaws.sts.synthetic",
  154    154   
    "AssumeRoleInput",
  155    155   
);
  156    156   
static ASSUMEROLEINPUT_MEMBER_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$RoleArn",
  159    159   
        "com.amazonaws.sts.synthetic",
  160    160   
        "AssumeRoleInput",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163         -
    "role_arn",
         163  +
    "RoleArn",
  164    164   
    0,
  165    165   
);
  166    166   
static ASSUMEROLEINPUT_MEMBER_ROLE_SESSION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static(
  168    168   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$RoleSessionName",
  169    169   
        "com.amazonaws.sts.synthetic",
  170    170   
        "AssumeRoleInput",
  171    171   
    ),
  172    172   
    ::aws_smithy_schema::ShapeType::String,
  173         -
    "role_session_name",
         173  +
    "RoleSessionName",
  174    174   
    1,
  175    175   
);
  176    176   
static ASSUMEROLEINPUT_MEMBER_POLICY_ARNS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  177    177   
    ::aws_smithy_schema::ShapeId::from_static(
  178    178   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$PolicyArns",
  179    179   
        "com.amazonaws.sts.synthetic",
  180    180   
        "AssumeRoleInput",
  181    181   
    ),
  182    182   
    ::aws_smithy_schema::ShapeType::List,
  183         -
    "policy_arns",
         183  +
    "PolicyArns",
  184    184   
    2,
  185    185   
);
  186    186   
static ASSUMEROLEINPUT_MEMBER_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  187    187   
    ::aws_smithy_schema::ShapeId::from_static(
  188    188   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$Policy",
  189    189   
        "com.amazonaws.sts.synthetic",
  190    190   
        "AssumeRoleInput",
  191    191   
    ),
  192    192   
    ::aws_smithy_schema::ShapeType::String,
  193         -
    "policy",
         193  +
    "Policy",
  194    194   
    3,
  195    195   
);
  196    196   
static ASSUMEROLEINPUT_MEMBER_DURATION_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  197    197   
    ::aws_smithy_schema::ShapeId::from_static(
  198    198   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$DurationSeconds",
  199    199   
        "com.amazonaws.sts.synthetic",
  200    200   
        "AssumeRoleInput",
  201    201   
    ),
  202    202   
    ::aws_smithy_schema::ShapeType::Integer,
  203         -
    "duration_seconds",
         203  +
    "DurationSeconds",
  204    204   
    4,
  205    205   
);
  206    206   
static ASSUMEROLEINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static(
  208    208   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$Tags",
  209    209   
        "com.amazonaws.sts.synthetic",
  210    210   
        "AssumeRoleInput",
  211    211   
    ),
  212    212   
    ::aws_smithy_schema::ShapeType::List,
  213         -
    "tags",
         213  +
    "Tags",
  214    214   
    5,
  215    215   
);
  216    216   
static ASSUMEROLEINPUT_MEMBER_TRANSITIVE_TAG_KEYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  217    217   
    ::aws_smithy_schema::ShapeId::from_static(
  218    218   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$TransitiveTagKeys",
  219    219   
        "com.amazonaws.sts.synthetic",
  220    220   
        "AssumeRoleInput",
  221    221   
    ),
  222    222   
    ::aws_smithy_schema::ShapeType::List,
  223         -
    "transitive_tag_keys",
         223  +
    "TransitiveTagKeys",
  224    224   
    6,
  225    225   
);
  226    226   
static ASSUMEROLEINPUT_MEMBER_EXTERNAL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  227    227   
    ::aws_smithy_schema::ShapeId::from_static(
  228    228   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$ExternalId",
  229    229   
        "com.amazonaws.sts.synthetic",
  230    230   
        "AssumeRoleInput",
  231    231   
    ),
  232    232   
    ::aws_smithy_schema::ShapeType::String,
  233         -
    "external_id",
         233  +
    "ExternalId",
  234    234   
    7,
  235    235   
);
  236    236   
static ASSUMEROLEINPUT_MEMBER_SERIAL_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  237    237   
    ::aws_smithy_schema::ShapeId::from_static(
  238    238   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$SerialNumber",
  239    239   
        "com.amazonaws.sts.synthetic",
  240    240   
        "AssumeRoleInput",
  241    241   
    ),
  242    242   
    ::aws_smithy_schema::ShapeType::String,
  243         -
    "serial_number",
         243  +
    "SerialNumber",
  244    244   
    8,
  245    245   
);
  246    246   
static ASSUMEROLEINPUT_MEMBER_TOKEN_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  247    247   
    ::aws_smithy_schema::ShapeId::from_static(
  248    248   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$TokenCode",
  249    249   
        "com.amazonaws.sts.synthetic",
  250    250   
        "AssumeRoleInput",
  251    251   
    ),
  252    252   
    ::aws_smithy_schema::ShapeType::String,
  253         -
    "token_code",
         253  +
    "TokenCode",
  254    254   
    9,
  255    255   
);
  256    256   
static ASSUMEROLEINPUT_MEMBER_SOURCE_IDENTITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  257    257   
    ::aws_smithy_schema::ShapeId::from_static(
  258    258   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$SourceIdentity",
  259    259   
        "com.amazonaws.sts.synthetic",
  260    260   
        "AssumeRoleInput",
  261    261   
    ),
  262    262   
    ::aws_smithy_schema::ShapeType::String,
  263         -
    "source_identity",
         263  +
    "SourceIdentity",
  264    264   
    10,
  265    265   
);
  266    266   
static ASSUMEROLEINPUT_MEMBER_PROVIDED_CONTEXTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  267    267   
    ::aws_smithy_schema::ShapeId::from_static(
  268    268   
        "com.amazonaws.sts.synthetic#AssumeRoleInput$ProvidedContexts",
  269    269   
        "com.amazonaws.sts.synthetic",
  270    270   
        "AssumeRoleInput",
  271    271   
    ),
  272    272   
    ::aws_smithy_schema::ShapeType::List,
  273         -
    "provided_contexts",
         273  +
    "ProvidedContexts",
  274    274   
    11,
  275    275   
);
  276    276   
static ASSUMEROLEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  277    277   
    ASSUMEROLEINPUT_SCHEMA_ID,
  278    278   
    ::aws_smithy_schema::ShapeType::Structure,
  279    279   
    &[
  280    280   
        &ASSUMEROLEINPUT_MEMBER_ROLE_ARN,
  281    281   
        &ASSUMEROLEINPUT_MEMBER_ROLE_SESSION_NAME,
  282    282   
        &ASSUMEROLEINPUT_MEMBER_POLICY_ARNS,
  283    283   
        &ASSUMEROLEINPUT_MEMBER_POLICY,
@@ -347,347 +505,499 @@
  367    367   
                    }
  368    368   
                    Ok(())
  369    369   
                },
  370    370   
            )?;
  371    371   
        }
  372    372   
        Ok(())
  373    373   
    }
  374    374   
}
  375    375   
impl AssumeRoleInput {
  376    376   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  377         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  378         -
        deserializer: &mut D,
         377  +
    pub fn deserialize(
         378  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  379    379   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  380    380   
        #[allow(unused_variables, unused_mut)]
  381    381   
        let mut builder = Self::builder();
  382    382   
        #[allow(
  383    383   
            unused_variables,
  384    384   
            unreachable_code,
  385    385   
            clippy::single_match,
  386    386   
            clippy::match_single_binding,
  387    387   
            clippy::diverging_sub_expression
  388    388   
        )]
  389         -
        deserializer.read_struct(&ASSUMEROLEINPUT_SCHEMA, (), |_, member, deser| {
         389  +
        deserializer.read_struct(&ASSUMEROLEINPUT_SCHEMA, &mut |member, deser| {
  390    390   
            match member.member_index() {
  391    391   
                Some(0) => {
  392    392   
                    builder.role_arn = Some(deser.read_string(member)?);
  393    393   
                }
  394    394   
                Some(1) => {
  395    395   
                    builder.role_session_name = Some(deser.read_string(member)?);
  396    396   
                }
  397    397   
                Some(2) => {
  398    398   
                    builder.policy_arns = Some({
  399         -
                        let container = if let Some(cap) = deser.container_size() {
  400         -
                            Vec::with_capacity(cap)
  401         -
                        } else {
  402         -
                            Vec::new()
  403         -
                        };
  404         -
                        deser.read_list(member, container, |mut list, deser| {
  405         -
                            list.push(crate::types::PolicyDescriptorType::deserialize(deser)?);
  406         -
                            Ok(list)
  407         -
                        })?
         399  +
                        let mut container = Vec::new();
         400  +
                        deser.read_list(member, &mut |deser| {
         401  +
                            container.push(crate::types::PolicyDescriptorType::deserialize(deser)?);
         402  +
                            Ok(())
         403  +
                        })?;
         404  +
                        container
  408    405   
                    });
  409    406   
                }
  410    407   
                Some(3) => {
  411    408   
                    builder.policy = Some(deser.read_string(member)?);
  412    409   
                }
  413    410   
                Some(4) => {
  414    411   
                    builder.duration_seconds = Some(deser.read_integer(member)?);
  415    412   
                }
  416    413   
                Some(5) => {
  417    414   
                    builder.tags = Some({
  418         -
                        let container = if let Some(cap) = deser.container_size() {
  419         -
                            Vec::with_capacity(cap)
  420         -
                        } else {
  421         -
                            Vec::new()
  422         -
                        };
  423         -
                        deser.read_list(member, container, |mut list, deser| {
  424         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  425         -
                            Ok(list)
  426         -
                        })?
         415  +
                        let mut container = Vec::new();
         416  +
                        deser.read_list(member, &mut |deser| {
         417  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         418  +
                            Ok(())
         419  +
                        })?;
         420  +
                        container
  427    421   
                    });
  428    422   
                }
  429    423   
                Some(6) => {
  430         -
                    builder.transitive_tag_keys = Some({
  431         -
                        let container = if let Some(cap) = deser.container_size() {
  432         -
                            Vec::with_capacity(cap)
  433         -
                        } else {
  434         -
                            Vec::new()
  435         -
                        };
  436         -
                        deser.read_list(member, container, |mut list, deser| {
  437         -
                            list.push(deser.read_string(member)?);
  438         -
                            Ok(list)
  439         -
                        })?
  440         -
                    });
         424  +
                    builder.transitive_tag_keys = Some(deser.read_string_list(member)?);
  441    425   
                }
  442    426   
                Some(7) => {
  443    427   
                    builder.external_id = Some(deser.read_string(member)?);
  444    428   
                }
  445    429   
                Some(8) => {
  446    430   
                    builder.serial_number = Some(deser.read_string(member)?);
  447    431   
                }
  448    432   
                Some(9) => {
  449    433   
                    builder.token_code = Some(deser.read_string(member)?);
  450    434   
                }
  451    435   
                Some(10) => {
  452    436   
                    builder.source_identity = Some(deser.read_string(member)?);
  453    437   
                }
  454    438   
                Some(11) => {
  455    439   
                    builder.provided_contexts = Some({
  456         -
                        let container = if let Some(cap) = deser.container_size() {
  457         -
                            Vec::with_capacity(cap)
  458         -
                        } else {
  459         -
                            Vec::new()
  460         -
                        };
  461         -
                        deser.read_list(member, container, |mut list, deser| {
  462         -
                            list.push(crate::types::ProvidedContext::deserialize(deser)?);
  463         -
                            Ok(list)
  464         -
                        })?
         440  +
                        let mut container = Vec::new();
         441  +
                        deser.read_list(member, &mut |deser| {
         442  +
                            container.push(crate::types::ProvidedContext::deserialize(deser)?);
         443  +
                            Ok(())
         444  +
                        })?;
         445  +
                        container
  465    446   
                    });
  466    447   
                }
  467    448   
                _ => {}
  468    449   
            }
  469    450   
            Ok(())
  470    451   
        })?;
         452  +
        builder.role_arn = builder.role_arn.or(Some(String::new()));
         453  +
        builder.role_session_name = builder.role_session_name.or(Some(String::new()));
  471    454   
        builder
  472    455   
            .build()
  473    456   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  474    457   
    }
  475    458   
}
         459  +
impl AssumeRoleInput {
         460  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         461  +
    pub fn deserialize_with_response(
         462  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         463  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         464  +
        _status: u16,
         465  +
        _body: &[u8],
         466  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         467  +
        Self::deserialize(deserializer)
         468  +
    }
         469  +
}
  476    470   
impl AssumeRoleInput {
  477    471   
    /// Creates a new builder-style object to manufacture [`AssumeRoleInput`](crate::operation::assume_role::AssumeRoleInput).
  478    472   
    pub fn builder() -> crate::operation::assume_role::builders::AssumeRoleInputBuilder {
  479    473   
        crate::operation::assume_role::builders::AssumeRoleInputBuilder::default()
  480    474   
    }
  481    475   
}
  482    476   
  483    477   
/// A builder for [`AssumeRoleInput`](crate::operation::assume_role::AssumeRoleInput).
  484    478   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  485    479   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/sts/src/operation/assume_role/_assume_role_output.rs

@@ -36,36 +178,232 @@
   56     56   
    "com.amazonaws.sts.synthetic",
   57     57   
    "AssumeRoleOutput",
   58     58   
);
   59     59   
static ASSUMEROLEOUTPUT_MEMBER_CREDENTIALS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.sts.synthetic#AssumeRoleOutput$Credentials",
   62     62   
        "com.amazonaws.sts.synthetic",
   63     63   
        "AssumeRoleOutput",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66         -
    "credentials",
          66  +
    "Credentials",
   67     67   
    0,
   68     68   
);
   69     69   
static ASSUMEROLEOUTPUT_MEMBER_ASSUMED_ROLE_USER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.sts.synthetic#AssumeRoleOutput$AssumedRoleUser",
   72     72   
        "com.amazonaws.sts.synthetic",
   73     73   
        "AssumeRoleOutput",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Structure,
   76         -
    "assumed_role_user",
          76  +
    "AssumedRoleUser",
   77     77   
    1,
   78     78   
);
   79     79   
static ASSUMEROLEOUTPUT_MEMBER_PACKED_POLICY_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.sts.synthetic#AssumeRoleOutput$PackedPolicySize",
   82     82   
        "com.amazonaws.sts.synthetic",
   83     83   
        "AssumeRoleOutput",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::Integer,
   86         -
    "packed_policy_size",
          86  +
    "PackedPolicySize",
   87     87   
    2,
   88     88   
);
   89     89   
static ASSUMEROLEOUTPUT_MEMBER_SOURCE_IDENTITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.sts.synthetic#AssumeRoleOutput$SourceIdentity",
   92     92   
        "com.amazonaws.sts.synthetic",
   93     93   
        "AssumeRoleOutput",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "source_identity",
          96  +
    "SourceIdentity",
   97     97   
    3,
   98     98   
);
          99  +
static ASSUMEROLEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         100  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         101  +
    ::aws_smithy_schema::ShapeType::String,
         102  +
    "request_id",
         103  +
    4,
         104  +
)
         105  +
.with_http_header("x-amzn-requestid");
   99    106   
static ASSUMEROLEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  100    107   
    ASSUMEROLEOUTPUT_SCHEMA_ID,
  101    108   
    ::aws_smithy_schema::ShapeType::Structure,
  102    109   
    &[
  103    110   
        &ASSUMEROLEOUTPUT_MEMBER_CREDENTIALS,
  104    111   
        &ASSUMEROLEOUTPUT_MEMBER_ASSUMED_ROLE_USER,
  105    112   
        &ASSUMEROLEOUTPUT_MEMBER_PACKED_POLICY_SIZE,
  106    113   
        &ASSUMEROLEOUTPUT_MEMBER_SOURCE_IDENTITY,
         114  +
        &ASSUMEROLEOUTPUT_MEMBER__REQUEST_ID,
  107    115   
    ],
  108    116   
);
  109    117   
impl AssumeRoleOutput {
  110    118   
    /// The schema for this shape.
  111    119   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ASSUMEROLEOUTPUT_SCHEMA;
  112    120   
}
  113    121   
impl ::aws_smithy_schema::serde::SerializableStruct for AssumeRoleOutput {
  114    122   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  115    123   
    fn serialize_members(
  116    124   
        &self,
  117    125   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  118    126   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  119    127   
        if let Some(ref val) = self.credentials {
  120    128   
            ser.write_struct(&ASSUMEROLEOUTPUT_MEMBER_CREDENTIALS, val)?;
  121    129   
        }
  122    130   
        if let Some(ref val) = self.assumed_role_user {
  123    131   
            ser.write_struct(&ASSUMEROLEOUTPUT_MEMBER_ASSUMED_ROLE_USER, val)?;
  124    132   
        }
  125    133   
        if let Some(ref val) = self.packed_policy_size {
  126    134   
            ser.write_integer(&ASSUMEROLEOUTPUT_MEMBER_PACKED_POLICY_SIZE, *val)?;
  127    135   
        }
  128    136   
        if let Some(ref val) = self.source_identity {
  129    137   
            ser.write_string(&ASSUMEROLEOUTPUT_MEMBER_SOURCE_IDENTITY, val)?;
  130    138   
        }
  131    139   
        Ok(())
  132    140   
    }
  133    141   
}
  134    142   
impl AssumeRoleOutput {
  135    143   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  136         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  137         -
        deserializer: &mut D,
         144  +
    pub fn deserialize(
         145  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         146  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         147  +
        #[allow(unused_variables, unused_mut)]
         148  +
        let mut builder = Self::builder();
         149  +
        #[allow(
         150  +
            unused_variables,
         151  +
            unreachable_code,
         152  +
            clippy::single_match,
         153  +
            clippy::match_single_binding,
         154  +
            clippy::diverging_sub_expression
         155  +
        )]
         156  +
        deserializer.read_struct(&ASSUMEROLEOUTPUT_SCHEMA, &mut |member, deser| {
         157  +
            match member.member_index() {
         158  +
                Some(0) => {
         159  +
                    builder.credentials = Some(crate::types::Credentials::deserialize(deser)?);
         160  +
                }
         161  +
                Some(1) => {
         162  +
                    builder.assumed_role_user = Some(crate::types::AssumedRoleUser::deserialize(deser)?);
         163  +
                }
         164  +
                Some(2) => {
         165  +
                    builder.packed_policy_size = Some(deser.read_integer(member)?);
         166  +
                }
         167  +
                Some(3) => {
         168  +
                    builder.source_identity = Some(deser.read_string(member)?);
         169  +
                }
         170  +
                Some(4) => {
         171  +
                    builder._request_id = Some(deser.read_string(member)?);
         172  +
                }
         173  +
                _ => {}
         174  +
            }
         175  +
            Ok(())
         176  +
        })?;
         177  +
        Ok(builder.build())
         178  +
    }
         179  +
}
         180  +
impl AssumeRoleOutput {
         181  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         182  +
    /// Header-bound members are read directly from headers, avoiding runtime
         183  +
    /// member iteration overhead. Body members are read via the deserializer.
         184  +
    pub fn deserialize_with_response(
         185  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         186  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         187  +
        _status: u16,
         188  +
        _body: &[u8],
  138    189   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  139    190   
        #[allow(unused_variables, unused_mut)]
  140    191   
        let mut builder = Self::builder();
         192  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         193  +
            builder._request_id = Some(val.to_string());
         194  +
        }
  141    195   
        #[allow(
  142    196   
            unused_variables,
  143    197   
            unreachable_code,
  144    198   
            clippy::single_match,
  145    199   
            clippy::match_single_binding,
  146    200   
            clippy::diverging_sub_expression
  147    201   
        )]
  148         -
        deserializer.read_struct(&ASSUMEROLEOUTPUT_SCHEMA, (), |_, member, deser| {
         202  +
        deserializer.read_struct(&ASSUMEROLEOUTPUT_SCHEMA, &mut |member, deser| {
  149    203   
            match member.member_index() {
  150    204   
                Some(0) => {
  151    205   
                    builder.credentials = Some(crate::types::Credentials::deserialize(deser)?);
  152    206   
                }
  153    207   
                Some(1) => {
  154    208   
                    builder.assumed_role_user = Some(crate::types::AssumedRoleUser::deserialize(deser)?);
  155    209   
                }
  156    210   
                Some(2) => {
  157    211   
                    builder.packed_policy_size = Some(deser.read_integer(member)?);
  158    212   
                }