AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

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

@@ -19,19 +150,150 @@
   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     96   
version = "1.7.3"
   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   
                }

tmp-codegen-diff/aws-sdk/sdk/sts/src/operation/assume_role_with_saml.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 `AssumeRoleWithSAML`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct AssumeRoleWithSAML;
    6      6   
impl AssumeRoleWithSAML {
    7      7   
    /// Creates a new `AssumeRoleWithSAML`
    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_with_saml::AssumeRoleWithSamlInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::assume_role_with_saml::AssumeRoleWithSamlOutput::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_with_saml::AssumeRoleWithSamlInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::assume_role_with_saml::AssumeRoleWithSamlOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -106,110 +168,173 @@
  126    130   
                crate::operation::assume_role_with_saml::AssumeRoleWithSAMLError,
  127    131   
            >::new());
  128    132   
  129    133   
        ::std::borrow::Cow::Owned(rcb)
  130    134   
    }
  131    135   
}
  132    136   
  133    137   
#[derive(Debug)]
  134    138   
struct AssumeRoleWithSAMLResponseDeserializer;
  135    139   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for AssumeRoleWithSAMLResponseDeserializer {
  136         -
    fn deserialize_nonstreaming(
         140  +
    fn deserialize_nonstreaming_with_config(
  137    141   
        &self,
  138    142   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         143  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  139    144   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  140    145   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  141    146   
        let headers = response.headers();
  142    147   
        let body = response.body().bytes().expect("body loaded");
  143    148   
        #[allow(unused_mut)]
  144    149   
        let mut force_error = false;
  145    150   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  146    151   
        let parse_result = if !success && status != 200 || force_error {
  147    152   
            crate::protocol_serde::shape_assume_role_with_saml::de_assume_role_with_saml_http_error(status, headers, body)
  148    153   
        } else {

tmp-codegen-diff/aws-sdk/sdk/sts/src/operation/assume_role_with_saml/_assume_role_with_saml_input.rs

@@ -67,67 +283,294 @@
   87     87   
    "com.amazonaws.sts.synthetic",
   88     88   
    "AssumeRoleWithSAMLInput",
   89     89   
);
   90     90   
static ASSUMEROLEWITHSAMLINPUT_MEMBER_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLInput$RoleArn",
   93     93   
        "com.amazonaws.sts.synthetic",
   94     94   
        "AssumeRoleWithSAMLInput",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "role_arn",
          97  +
    "RoleArn",
   98     98   
    0,
   99     99   
);
  100    100   
static ASSUMEROLEWITHSAMLINPUT_MEMBER_PRINCIPAL_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLInput$PrincipalArn",
  103    103   
        "com.amazonaws.sts.synthetic",
  104    104   
        "AssumeRoleWithSAMLInput",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "principal_arn",
         107  +
    "PrincipalArn",
  108    108   
    1,
  109    109   
);
  110    110   
static ASSUMEROLEWITHSAMLINPUT_MEMBER_SAML_ASSERTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLInput$SAMLAssertion",
  113    113   
        "com.amazonaws.sts.synthetic",
  114    114   
        "AssumeRoleWithSAMLInput",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::String,
  117         -
    "saml_assertion",
         117  +
    "SAMLAssertion",
  118    118   
    2,
  119    119   
);
  120    120   
static ASSUMEROLEWITHSAMLINPUT_MEMBER_POLICY_ARNS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static(
  122    122   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLInput$PolicyArns",
  123    123   
        "com.amazonaws.sts.synthetic",
  124    124   
        "AssumeRoleWithSAMLInput",
  125    125   
    ),
  126    126   
    ::aws_smithy_schema::ShapeType::List,
  127         -
    "policy_arns",
         127  +
    "PolicyArns",
  128    128   
    3,
  129    129   
);
  130    130   
static ASSUMEROLEWITHSAMLINPUT_MEMBER_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLInput$Policy",
  133    133   
        "com.amazonaws.sts.synthetic",
  134    134   
        "AssumeRoleWithSAMLInput",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::String,
  137         -
    "policy",
         137  +
    "Policy",
  138    138   
    4,
  139    139   
);
  140    140   
static ASSUMEROLEWITHSAMLINPUT_MEMBER_DURATION_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLInput$DurationSeconds",
  143    143   
        "com.amazonaws.sts.synthetic",
  144    144   
        "AssumeRoleWithSAMLInput",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::Integer,
  147         -
    "duration_seconds",
         147  +
    "DurationSeconds",
  148    148   
    5,
  149    149   
);
  150    150   
static ASSUMEROLEWITHSAMLINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  151    151   
    ASSUMEROLEWITHSAMLINPUT_SCHEMA_ID,
  152    152   
    ::aws_smithy_schema::ShapeType::Structure,
  153    153   
    &[
  154    154   
        &ASSUMEROLEWITHSAMLINPUT_MEMBER_ROLE_ARN,
  155    155   
        &ASSUMEROLEWITHSAMLINPUT_MEMBER_PRINCIPAL_ARN,
  156    156   
        &ASSUMEROLEWITHSAMLINPUT_MEMBER_SAML_ASSERTION,
  157    157   
        &ASSUMEROLEWITHSAMLINPUT_MEMBER_POLICY_ARNS,
  158    158   
        &ASSUMEROLEWITHSAMLINPUT_MEMBER_POLICY,
  159    159   
        &ASSUMEROLEWITHSAMLINPUT_MEMBER_DURATION_SECONDS,
  160    160   
    ],
  161    161   
);
  162    162   
impl AssumeRoleWithSamlInput {
  163    163   
    /// The schema for this shape.
  164    164   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ASSUMEROLEWITHSAMLINPUT_SCHEMA;
  165    165   
}
  166    166   
impl ::aws_smithy_schema::serde::SerializableStruct for AssumeRoleWithSamlInput {
  167    167   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  168    168   
    fn serialize_members(
  169    169   
        &self,
  170    170   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  171    171   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  172    172   
        if let Some(ref val) = self.role_arn {
  173    173   
            ser.write_string(&ASSUMEROLEWITHSAMLINPUT_MEMBER_ROLE_ARN, val)?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.principal_arn {
  176    176   
            ser.write_string(&ASSUMEROLEWITHSAMLINPUT_MEMBER_PRINCIPAL_ARN, val)?;
  177    177   
        }
  178    178   
        if let Some(ref val) = self.saml_assertion {
  179    179   
            ser.write_string(&ASSUMEROLEWITHSAMLINPUT_MEMBER_SAML_ASSERTION, val)?;
  180    180   
        }
  181    181   
        if let Some(ref val) = self.policy_arns {
  182    182   
            ser.write_list(
  183    183   
                &ASSUMEROLEWITHSAMLINPUT_MEMBER_POLICY_ARNS,
  184    184   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  185    185   
                    for item in val {
  186    186   
                        ser.write_struct(crate::types::PolicyDescriptorType::SCHEMA, item)?;
  187    187   
                    }
  188    188   
                    Ok(())
  189    189   
                },
  190    190   
            )?;
  191    191   
        }
  192    192   
        if let Some(ref val) = self.policy {
  193    193   
            ser.write_string(&ASSUMEROLEWITHSAMLINPUT_MEMBER_POLICY, val)?;
  194    194   
        }
  195    195   
        if let Some(ref val) = self.duration_seconds {
  196    196   
            ser.write_integer(&ASSUMEROLEWITHSAMLINPUT_MEMBER_DURATION_SECONDS, *val)?;
  197    197   
        }
  198    198   
        Ok(())
  199    199   
    }
  200    200   
}
  201    201   
impl AssumeRoleWithSamlInput {
  202    202   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  203         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  204         -
        deserializer: &mut D,
         203  +
    pub fn deserialize(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  205    205   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  206    206   
        #[allow(unused_variables, unused_mut)]
  207    207   
        let mut builder = Self::builder();
  208    208   
        #[allow(
  209    209   
            unused_variables,
  210    210   
            unreachable_code,
  211    211   
            clippy::single_match,
  212    212   
            clippy::match_single_binding,
  213    213   
            clippy::diverging_sub_expression
  214    214   
        )]
  215         -
        deserializer.read_struct(&ASSUMEROLEWITHSAMLINPUT_SCHEMA, (), |_, member, deser| {
         215  +
        deserializer.read_struct(&ASSUMEROLEWITHSAMLINPUT_SCHEMA, &mut |member, deser| {
  216    216   
            match member.member_index() {
  217    217   
                Some(0) => {
  218    218   
                    builder.role_arn = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                Some(1) => {
  221    221   
                    builder.principal_arn = Some(deser.read_string(member)?);
  222    222   
                }
  223    223   
                Some(2) => {
  224    224   
                    builder.saml_assertion = Some(deser.read_string(member)?);
  225    225   
                }
  226    226   
                Some(3) => {
  227    227   
                    builder.policy_arns = Some({
  228         -
                        let container = if let Some(cap) = deser.container_size() {
  229         -
                            Vec::with_capacity(cap)
  230         -
                        } else {
  231         -
                            Vec::new()
  232         -
                        };
  233         -
                        deser.read_list(member, container, |mut list, deser| {
  234         -
                            list.push(crate::types::PolicyDescriptorType::deserialize(deser)?);
  235         -
                            Ok(list)
  236         -
                        })?
         228  +
                        let mut container = Vec::new();
         229  +
                        deser.read_list(member, &mut |deser| {
         230  +
                            container.push(crate::types::PolicyDescriptorType::deserialize(deser)?);
         231  +
                            Ok(())
         232  +
                        })?;
         233  +
                        container
  237    234   
                    });
  238    235   
                }
  239    236   
                Some(4) => {
  240    237   
                    builder.policy = Some(deser.read_string(member)?);
  241    238   
                }
  242    239   
                Some(5) => {
  243    240   
                    builder.duration_seconds = Some(deser.read_integer(member)?);
  244    241   
                }
  245    242   
                _ => {}
  246    243   
            }
  247    244   
            Ok(())
  248    245   
        })?;
         246  +
        builder.role_arn = builder.role_arn.or(Some(String::new()));
         247  +
        builder.principal_arn = builder.principal_arn.or(Some(String::new()));
         248  +
        builder.saml_assertion = builder.saml_assertion.or(Some(String::new()));
  249    249   
        builder
  250    250   
            .build()
  251    251   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  252    252   
    }
  253    253   
}
         254  +
impl AssumeRoleWithSamlInput {
         255  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         256  +
    pub fn deserialize_with_response(
         257  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         258  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         259  +
        _status: u16,
         260  +
        _body: &[u8],
         261  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         262  +
        Self::deserialize(deserializer)
         263  +
    }
         264  +
}
  254    265   
impl AssumeRoleWithSamlInput {
  255    266   
    /// Creates a new builder-style object to manufacture [`AssumeRoleWithSamlInput`](crate::operation::assume_role_with_saml::AssumeRoleWithSamlInput).
  256    267   
    pub fn builder() -> crate::operation::assume_role_with_saml::builders::AssumeRoleWithSamlInputBuilder {
  257    268   
        crate::operation::assume_role_with_saml::builders::AssumeRoleWithSamlInputBuilder::default()
  258    269   
    }
  259    270   
}
  260    271   
  261    272   
/// A builder for [`AssumeRoleWithSamlInput`](crate::operation::assume_role_with_saml::AssumeRoleWithSamlInput).
  262    273   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  263    274   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/sts/src/operation/assume_role_with_saml/_assume_role_with_saml_output.rs

@@ -95,95 +307,376 @@
  115    115   
    "com.amazonaws.sts.synthetic",
  116    116   
    "AssumeRoleWithSAMLOutput",
  117    117   
);
  118    118   
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER_CREDENTIALS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLOutput$Credentials",
  121    121   
        "com.amazonaws.sts.synthetic",
  122    122   
        "AssumeRoleWithSAMLOutput",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::Structure,
  125         -
    "credentials",
         125  +
    "Credentials",
  126    126   
    0,
  127    127   
);
  128    128   
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER_ASSUMED_ROLE_USER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLOutput$AssumedRoleUser",
  131    131   
        "com.amazonaws.sts.synthetic",
  132    132   
        "AssumeRoleWithSAMLOutput",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::Structure,
  135         -
    "assumed_role_user",
         135  +
    "AssumedRoleUser",
  136    136   
    1,
  137    137   
);
  138    138   
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER_PACKED_POLICY_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static(
  140    140   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLOutput$PackedPolicySize",
  141    141   
        "com.amazonaws.sts.synthetic",
  142    142   
        "AssumeRoleWithSAMLOutput",
  143    143   
    ),
  144    144   
    ::aws_smithy_schema::ShapeType::Integer,
  145         -
    "packed_policy_size",
         145  +
    "PackedPolicySize",
  146    146   
    2,
  147    147   
);
  148    148   
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER_SUBJECT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  149    149   
    ::aws_smithy_schema::ShapeId::from_static(
  150    150   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLOutput$Subject",
  151    151   
        "com.amazonaws.sts.synthetic",
  152    152   
        "AssumeRoleWithSAMLOutput",
  153    153   
    ),
  154    154   
    ::aws_smithy_schema::ShapeType::String,
  155         -
    "subject",
         155  +
    "Subject",
  156    156   
    3,
  157    157   
);
  158    158   
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER_SUBJECT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLOutput$SubjectType",
  161    161   
        "com.amazonaws.sts.synthetic",
  162    162   
        "AssumeRoleWithSAMLOutput",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::String,
  165         -
    "subject_type",
         165  +
    "SubjectType",
  166    166   
    4,
  167    167   
);
  168    168   
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER_ISSUER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLOutput$Issuer",
  171    171   
        "com.amazonaws.sts.synthetic",
  172    172   
        "AssumeRoleWithSAMLOutput",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::String,
  175         -
    "issuer",
         175  +
    "Issuer",
  176    176   
    5,
  177    177   
);
  178    178   
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER_AUDIENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLOutput$Audience",
  181    181   
        "com.amazonaws.sts.synthetic",
  182    182   
        "AssumeRoleWithSAMLOutput",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "audience",
         185  +
    "Audience",
  186    186   
    6,
  187    187   
);
  188    188   
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER_NAME_QUALIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  189    189   
    ::aws_smithy_schema::ShapeId::from_static(
  190    190   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLOutput$NameQualifier",
  191    191   
        "com.amazonaws.sts.synthetic",
  192    192   
        "AssumeRoleWithSAMLOutput",
  193    193   
    ),
  194    194   
    ::aws_smithy_schema::ShapeType::String,
  195         -
    "name_qualifier",
         195  +
    "NameQualifier",
  196    196   
    7,
  197    197   
);
  198    198   
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER_SOURCE_IDENTITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  199    199   
    ::aws_smithy_schema::ShapeId::from_static(
  200    200   
        "com.amazonaws.sts.synthetic#AssumeRoleWithSAMLOutput$SourceIdentity",
  201    201   
        "com.amazonaws.sts.synthetic",
  202    202   
        "AssumeRoleWithSAMLOutput",
  203    203   
    ),
  204    204   
    ::aws_smithy_schema::ShapeType::String,
  205         -
    "source_identity",
         205  +
    "SourceIdentity",
  206    206   
    8,
  207    207   
);
         208  +
static ASSUMEROLEWITHSAMLOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         209  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         210  +
    ::aws_smithy_schema::ShapeType::String,
         211  +
    "request_id",
         212  +
    9,
         213  +
)
         214  +
.with_http_header("x-amzn-requestid");
  208    215   
static ASSUMEROLEWITHSAMLOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  209    216   
    ASSUMEROLEWITHSAMLOUTPUT_SCHEMA_ID,
  210    217   
    ::aws_smithy_schema::ShapeType::Structure,
  211    218   
    &[
  212    219   
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER_CREDENTIALS,
  213    220   
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER_ASSUMED_ROLE_USER,
  214    221   
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER_PACKED_POLICY_SIZE,
  215    222   
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER_SUBJECT,
  216    223   
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER_SUBJECT_TYPE,
  217    224   
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER_ISSUER,
  218    225   
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER_AUDIENCE,
  219    226   
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER_NAME_QUALIFIER,
  220    227   
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER_SOURCE_IDENTITY,
         228  +
        &ASSUMEROLEWITHSAMLOUTPUT_MEMBER__REQUEST_ID,
  221    229   
    ],
  222    230   
);
  223    231   
impl AssumeRoleWithSamlOutput {
  224    232   
    /// The schema for this shape.
  225    233   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ASSUMEROLEWITHSAMLOUTPUT_SCHEMA;
  226    234   
}
  227    235   
impl ::aws_smithy_schema::serde::SerializableStruct for AssumeRoleWithSamlOutput {
  228    236   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  229    237   
    fn serialize_members(
  230    238   
        &self,
  231    239   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  232    240   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  233    241   
        if let Some(ref val) = self.credentials {
  234    242   
            ser.write_struct(&ASSUMEROLEWITHSAMLOUTPUT_MEMBER_CREDENTIALS, val)?;
  235    243   
        }
  236    244   
        if let Some(ref val) = self.assumed_role_user {
  237    245   
            ser.write_struct(&ASSUMEROLEWITHSAMLOUTPUT_MEMBER_ASSUMED_ROLE_USER, val)?;
  238    246   
        }
  239    247   
        if let Some(ref val) = self.packed_policy_size {
  240    248   
            ser.write_integer(&ASSUMEROLEWITHSAMLOUTPUT_MEMBER_PACKED_POLICY_SIZE, *val)?;
  241    249   
        }
  242    250   
        if let Some(ref val) = self.subject {
  243    251   
            ser.write_string(&ASSUMEROLEWITHSAMLOUTPUT_MEMBER_SUBJECT, val)?;
  244    252   
        }
  245    253   
        if let Some(ref val) = self.subject_type {
  246    254   
            ser.write_string(&ASSUMEROLEWITHSAMLOUTPUT_MEMBER_SUBJECT_TYPE, val)?;
  247    255   
        }
  248    256   
        if let Some(ref val) = self.issuer {
  249    257   
            ser.write_string(&ASSUMEROLEWITHSAMLOUTPUT_MEMBER_ISSUER, val)?;
  250    258   
        }
  251    259   
        if let Some(ref val) = self.audience {
  252    260   
            ser.write_string(&ASSUMEROLEWITHSAMLOUTPUT_MEMBER_AUDIENCE, val)?;
  253    261   
        }
  254    262   
        if let Some(ref val) = self.name_qualifier {
  255    263   
            ser.write_string(&ASSUMEROLEWITHSAMLOUTPUT_MEMBER_NAME_QUALIFIER, val)?;
  256    264   
        }
  257    265   
        if let Some(ref val) = self.source_identity {
  258    266   
            ser.write_string(&ASSUMEROLEWITHSAMLOUTPUT_MEMBER_SOURCE_IDENTITY, val)?;
  259    267   
        }
  260    268   
        Ok(())
  261    269   
    }
  262    270   
}
  263    271   
impl AssumeRoleWithSamlOutput {
  264    272   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  265         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  266         -
        deserializer: &mut D,
         273  +
    pub fn deserialize(
         274  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  267    275   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  268    276   
        #[allow(unused_variables, unused_mut)]
  269    277   
        let mut builder = Self::builder();
  270    278   
        #[allow(
  271    279   
            unused_variables,
  272    280   
            unreachable_code,
  273    281   
            clippy::single_match,
  274    282   
            clippy::match_single_binding,
  275    283   
            clippy::diverging_sub_expression
  276    284   
        )]
  277         -
        deserializer.read_struct(&ASSUMEROLEWITHSAMLOUTPUT_SCHEMA, (), |_, member, deser| {
         285  +
        deserializer.read_struct(&ASSUMEROLEWITHSAMLOUTPUT_SCHEMA, &mut |member, deser| {
         286  +
            match member.member_index() {
         287  +
                Some(0) => {
         288  +
                    builder.credentials = Some(crate::types::Credentials::deserialize(deser)?);
         289  +
                }
         290  +
                Some(1) => {
         291  +
                    builder.assumed_role_user = Some(crate::types::AssumedRoleUser::deserialize(deser)?);
         292  +
                }
         293  +
                Some(2) => {
         294  +
                    builder.packed_policy_size = Some(deser.read_integer(member)?);
         295  +
                }
         296  +
                Some(3) => {
         297  +
                    builder.subject = Some(deser.read_string(member)?);
         298  +
                }
         299  +
                Some(4) => {
         300  +
                    builder.subject_type = Some(deser.read_string(member)?);
         301  +
                }
         302  +
                Some(5) => {
         303  +
                    builder.issuer = Some(deser.read_string(member)?);
         304  +
                }
         305  +
                Some(6) => {
         306  +
                    builder.audience = Some(deser.read_string(member)?);
         307  +
                }
         308  +
                Some(7) => {
         309  +
                    builder.name_qualifier = Some(deser.read_string(member)?);
         310  +
                }
         311  +
                Some(8) => {
         312  +
                    builder.source_identity = Some(deser.read_string(member)?);
         313  +
                }
         314  +
                Some(9) => {
         315  +
                    builder._request_id = Some(deser.read_string(member)?);
         316  +
                }
         317  +
                _ => {}
         318  +
            }
         319  +
            Ok(())
         320  +
        })?;
         321  +
        Ok(builder.build())
         322  +
    }
         323  +
}
         324  +
impl AssumeRoleWithSamlOutput {
         325  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         326  +
    /// Header-bound members are read directly from headers, avoiding runtime
         327  +
    /// member iteration overhead. Body members are read via the deserializer.
         328  +
    pub fn deserialize_with_response(
         329  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         330  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         331  +
        _status: u16,
         332  +
        _body: &[u8],
         333  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         334  +
        #[allow(unused_variables, unused_mut)]
         335  +
        let mut builder = Self::builder();
         336  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         337  +
            builder._request_id = Some(val.to_string());
         338  +
        }
         339  +
        #[allow(
         340  +
            unused_variables,
         341  +
            unreachable_code,
         342  +
            clippy::single_match,
         343  +
            clippy::match_single_binding,
         344  +
            clippy::diverging_sub_expression
         345  +
        )]
         346  +
        deserializer.read_struct(&ASSUMEROLEWITHSAMLOUTPUT_SCHEMA, &mut |member, deser| {
  278    347   
            match member.member_index() {
  279    348   
                Some(0) => {
  280    349   
                    builder.credentials = Some(crate::types::Credentials::deserialize(deser)?);
  281    350   
                }
  282    351   
                Some(1) => {
  283    352   
                    builder.assumed_role_user = Some(crate::types::AssumedRoleUser::deserialize(deser)?);
  284    353   
                }
  285    354   
                Some(2) => {
  286    355   
                    builder.packed_policy_size = Some(deser.read_integer(member)?);
  287    356   
                }

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

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `AssumeRoleWithWebIdentity`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct AssumeRoleWithWebIdentity;
    6      6   
impl AssumeRoleWithWebIdentity {
    7      7   
    /// Creates a new `AssumeRoleWithWebIdentity`
    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 =
          13  +
        crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -109,115 +171,178 @@
  129    135   
                crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityError,
  130    136   
            >::new());
  131    137   
  132    138   
        ::std::borrow::Cow::Owned(rcb)
  133    139   
    }
  134    140   
}
  135    141   
  136    142   
#[derive(Debug)]
  137    143   
struct AssumeRoleWithWebIdentityResponseDeserializer;
  138    144   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for AssumeRoleWithWebIdentityResponseDeserializer {
  139         -
    fn deserialize_nonstreaming(
         145  +
    fn deserialize_nonstreaming_with_config(
  140    146   
        &self,
  141    147   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         148  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  142    149   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  143    150   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  144    151   
        let headers = response.headers();
  145    152   
        let body = response.body().bytes().expect("body loaded");
  146    153   
        #[allow(unused_mut)]
  147    154   
        let mut force_error = false;
  148    155   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  149    156   
        let parse_result = if !success && status != 200 || force_error {
  150    157   
            crate::protocol_serde::shape_assume_role_with_web_identity::de_assume_role_with_web_identity_http_error(status, headers, body)
  151    158   
        } else {

tmp-codegen-diff/aws-sdk/sdk/sts/src/operation/assume_role_with_web_identity/_assume_role_with_web_identity_input.rs

@@ -84,84 +317,328 @@
  104    104   
    "com.amazonaws.sts.synthetic",
  105    105   
    "AssumeRoleWithWebIdentityInput",
  106    106   
);
  107    107   
static ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.sts.synthetic#AssumeRoleWithWebIdentityInput$RoleArn",
  110    110   
        "com.amazonaws.sts.synthetic",
  111    111   
        "AssumeRoleWithWebIdentityInput",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "role_arn",
         114  +
    "RoleArn",
  115    115   
    0,
  116    116   
);
  117    117   
static ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_ROLE_SESSION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.sts.synthetic#AssumeRoleWithWebIdentityInput$RoleSessionName",
  120    120   
        "com.amazonaws.sts.synthetic",
  121    121   
        "AssumeRoleWithWebIdentityInput",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "role_session_name",
         124  +
    "RoleSessionName",
  125    125   
    1,
  126    126   
);
  127    127   
static ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_WEB_IDENTITY_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.sts.synthetic#AssumeRoleWithWebIdentityInput$WebIdentityToken",
  130    130   
        "com.amazonaws.sts.synthetic",
  131    131   
        "AssumeRoleWithWebIdentityInput",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::String,
  134         -
    "web_identity_token",
         134  +
    "WebIdentityToken",
  135    135   
    2,
  136    136   
);
  137    137   
static ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_PROVIDER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.sts.synthetic#AssumeRoleWithWebIdentityInput$ProviderId",
  140    140   
        "com.amazonaws.sts.synthetic",
  141    141   
        "AssumeRoleWithWebIdentityInput",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::String,
  144         -
    "provider_id",
         144  +
    "ProviderId",
  145    145   
    3,
  146    146   
);
  147    147   
static ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_POLICY_ARNS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static(
  149    149   
        "com.amazonaws.sts.synthetic#AssumeRoleWithWebIdentityInput$PolicyArns",
  150    150   
        "com.amazonaws.sts.synthetic",
  151    151   
        "AssumeRoleWithWebIdentityInput",
  152    152   
    ),
  153    153   
    ::aws_smithy_schema::ShapeType::List,
  154         -
    "policy_arns",
         154  +
    "PolicyArns",
  155    155   
    4,
  156    156   
);
  157    157   
static ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static(
  159    159   
        "com.amazonaws.sts.synthetic#AssumeRoleWithWebIdentityInput$Policy",
  160    160   
        "com.amazonaws.sts.synthetic",
  161    161   
        "AssumeRoleWithWebIdentityInput",
  162    162   
    ),
  163    163   
    ::aws_smithy_schema::ShapeType::String,
  164         -
    "policy",
         164  +
    "Policy",
  165    165   
    5,
  166    166   
);
  167    167   
static ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_DURATION_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  168    168   
    ::aws_smithy_schema::ShapeId::from_static(
  169    169   
        "com.amazonaws.sts.synthetic#AssumeRoleWithWebIdentityInput$DurationSeconds",
  170    170   
        "com.amazonaws.sts.synthetic",
  171    171   
        "AssumeRoleWithWebIdentityInput",
  172    172   
    ),
  173    173   
    ::aws_smithy_schema::ShapeType::Integer,
  174         -
    "duration_seconds",
         174  +
    "DurationSeconds",
  175    175   
    6,
  176    176   
);
  177    177   
static ASSUMEROLEWITHWEBIDENTITYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  178    178   
    ASSUMEROLEWITHWEBIDENTITYINPUT_SCHEMA_ID,
  179    179   
    ::aws_smithy_schema::ShapeType::Structure,
  180    180   
    &[
  181    181   
        &ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_ROLE_ARN,
  182    182   
        &ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_ROLE_SESSION_NAME,
  183    183   
        &ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_WEB_IDENTITY_TOKEN,
  184    184   
        &ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_PROVIDER_ID,
  185    185   
        &ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_POLICY_ARNS,
  186    186   
        &ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_POLICY,
  187    187   
        &ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_DURATION_SECONDS,
  188    188   
    ],
  189    189   
);
  190    190   
impl AssumeRoleWithWebIdentityInput {
  191    191   
    /// The schema for this shape.
  192    192   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ASSUMEROLEWITHWEBIDENTITYINPUT_SCHEMA;
  193    193   
}
  194    194   
impl ::aws_smithy_schema::serde::SerializableStruct for AssumeRoleWithWebIdentityInput {
  195    195   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  196    196   
    fn serialize_members(
  197    197   
        &self,
  198    198   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  199    199   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  200    200   
        if let Some(ref val) = self.role_arn {
  201    201   
            ser.write_string(&ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_ROLE_ARN, val)?;
  202    202   
        }
  203    203   
        if let Some(ref val) = self.role_session_name {
  204    204   
            ser.write_string(&ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_ROLE_SESSION_NAME, val)?;
  205    205   
        }
  206    206   
        if let Some(ref val) = self.web_identity_token {
  207    207   
            ser.write_string(&ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_WEB_IDENTITY_TOKEN, val)?;
  208    208   
        }
  209    209   
        if let Some(ref val) = self.provider_id {
  210    210   
            ser.write_string(&ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_PROVIDER_ID, val)?;
  211    211   
        }
  212    212   
        if let Some(ref val) = self.policy_arns {
  213    213   
            ser.write_list(
  214    214   
                &ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_POLICY_ARNS,
  215    215   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  216    216   
                    for item in val {
  217    217   
                        ser.write_struct(crate::types::PolicyDescriptorType::SCHEMA, item)?;
  218    218   
                    }
  219    219   
                    Ok(())
  220    220   
                },
  221    221   
            )?;
  222    222   
        }
  223    223   
        if let Some(ref val) = self.policy {
  224    224   
            ser.write_string(&ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_POLICY, val)?;
  225    225   
        }
  226    226   
        if let Some(ref val) = self.duration_seconds {
  227    227   
            ser.write_integer(&ASSUMEROLEWITHWEBIDENTITYINPUT_MEMBER_DURATION_SECONDS, *val)?;
  228    228   
        }
  229    229   
        Ok(())
  230    230   
    }
  231    231   
}
  232    232   
impl AssumeRoleWithWebIdentityInput {
  233    233   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  234         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  235         -
        deserializer: &mut D,
         234  +
    pub fn deserialize(
         235  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  236    236   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  237    237   
        #[allow(unused_variables, unused_mut)]
  238    238   
        let mut builder = Self::builder();
  239    239   
        #[allow(
  240    240   
            unused_variables,
  241    241   
            unreachable_code,
  242    242   
            clippy::single_match,
  243    243   
            clippy::match_single_binding,
  244    244   
            clippy::diverging_sub_expression
  245    245   
        )]
  246         -
        deserializer.read_struct(&ASSUMEROLEWITHWEBIDENTITYINPUT_SCHEMA, (), |_, member, deser| {
         246  +
        deserializer.read_struct(&ASSUMEROLEWITHWEBIDENTITYINPUT_SCHEMA, &mut |member, deser| {
  247    247   
            match member.member_index() {
  248    248   
                Some(0) => {
  249    249   
                    builder.role_arn = Some(deser.read_string(member)?);
  250    250   
                }
  251    251   
                Some(1) => {
  252    252   
                    builder.role_session_name = Some(deser.read_string(member)?);
  253    253   
                }
  254    254   
                Some(2) => {
  255    255   
                    builder.web_identity_token = Some(deser.read_string(member)?);
  256    256   
                }
  257    257   
                Some(3) => {
  258    258   
                    builder.provider_id = Some(deser.read_string(member)?);
  259    259   
                }
  260    260   
                Some(4) => {
  261    261   
                    builder.policy_arns = Some({
  262         -
                        let container = if let Some(cap) = deser.container_size() {
  263         -
                            Vec::with_capacity(cap)
  264         -
                        } else {
  265         -
                            Vec::new()
  266         -
                        };
  267         -
                        deser.read_list(member, container, |mut list, deser| {
  268         -
                            list.push(crate::types::PolicyDescriptorType::deserialize(deser)?);
  269         -
                            Ok(list)
  270         -
                        })?
         262  +
                        let mut container = Vec::new();
         263  +
                        deser.read_list(member, &mut |deser| {
         264  +
                            container.push(crate::types::PolicyDescriptorType::deserialize(deser)?);
         265  +
                            Ok(())
         266  +
                        })?;
         267  +
                        container
  271    268   
                    });
  272    269   
                }
  273    270   
                Some(5) => {
  274    271   
                    builder.policy = Some(deser.read_string(member)?);
  275    272   
                }
  276    273   
                Some(6) => {
  277    274   
                    builder.duration_seconds = Some(deser.read_integer(member)?);
  278    275   
                }
  279    276   
                _ => {}
  280    277   
            }
  281    278   
            Ok(())
  282    279   
        })?;
         280  +
        builder.role_arn = builder.role_arn.or(Some(String::new()));
         281  +
        builder.role_session_name = builder.role_session_name.or(Some(String::new()));
         282  +
        builder.web_identity_token = builder.web_identity_token.or(Some(String::new()));
  283    283   
        builder
  284    284   
            .build()
  285    285   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  286    286   
    }
  287    287   
}
         288  +
impl AssumeRoleWithWebIdentityInput {
         289  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         290  +
    pub fn deserialize_with_response(
         291  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         292  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         293  +
        _status: u16,
         294  +
        _body: &[u8],
         295  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         296  +
        Self::deserialize(deserializer)
         297  +
    }
         298  +
}
  288    299   
impl AssumeRoleWithWebIdentityInput {
  289    300   
    /// Creates a new builder-style object to manufacture [`AssumeRoleWithWebIdentityInput`](crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityInput).
  290    301   
    pub fn builder() -> crate::operation::assume_role_with_web_identity::builders::AssumeRoleWithWebIdentityInputBuilder {
  291    302   
        crate::operation::assume_role_with_web_identity::builders::AssumeRoleWithWebIdentityInputBuilder::default()
  292    303   
    }
  293    304   
}
  294    305   
  295    306   
/// A builder for [`AssumeRoleWithWebIdentityInput`](crate::operation::assume_role_with_web_identity::AssumeRoleWithWebIdentityInput).
  296    307   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  297    308   
#[non_exhaustive]