AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_access_key_last_used/_get_access_key_last_used_input.rs

@@ -1,1 +110,122 @@
   19     19   
    "com.amazonaws.iam.synthetic",
   20     20   
    "GetAccessKeyLastUsedInput",
   21     21   
);
   22     22   
static GETACCESSKEYLASTUSEDINPUT_MEMBER_ACCESS_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.iam.synthetic#GetAccessKeyLastUsedInput$AccessKeyId",
   25     25   
        "com.amazonaws.iam.synthetic",
   26     26   
        "GetAccessKeyLastUsedInput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "access_key_id",
          29  +
    "AccessKeyId",
   30     30   
    0,
   31     31   
);
   32     32   
static GETACCESSKEYLASTUSEDINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    GETACCESSKEYLASTUSEDINPUT_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&GETACCESSKEYLASTUSEDINPUT_MEMBER_ACCESS_KEY_ID],
   36     36   
);
   37     37   
impl GetAccessKeyLastUsedInput {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETACCESSKEYLASTUSEDINPUT_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAccessKeyLastUsedInput {
   42     42   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     43   
    fn serialize_members(
   44     44   
        &self,
   45     45   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     46   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     47   
        if let Some(ref val) = self.access_key_id {
   48     48   
            ser.write_string(&GETACCESSKEYLASTUSEDINPUT_MEMBER_ACCESS_KEY_ID, val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl GetAccessKeyLastUsedInput {
   54     54   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          55  +
    pub fn deserialize(
          56  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     57   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     58   
        #[allow(unused_variables, unused_mut)]
   59     59   
        let mut builder = Self::builder();
   60     60   
        #[allow(
   61     61   
            unused_variables,
   62     62   
            unreachable_code,
   63     63   
            clippy::single_match,
   64     64   
            clippy::match_single_binding,
   65     65   
            clippy::diverging_sub_expression
   66     66   
        )]
   67         -
        deserializer.read_struct(&GETACCESSKEYLASTUSEDINPUT_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&GETACCESSKEYLASTUSEDINPUT_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.access_key_id = Some(deser.read_string(member)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
          76  +
        builder.access_key_id = builder.access_key_id.or(Some(String::new()));
   76     77   
        builder
   77     78   
            .build()
   78     79   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   79     80   
    }
   80     81   
}
          82  +
impl GetAccessKeyLastUsedInput {
          83  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          84  +
    pub fn deserialize_with_response(
          85  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          86  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          87  +
        _status: u16,
          88  +
        _body: &[u8],
          89  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          90  +
        Self::deserialize(deserializer)
          91  +
    }
          92  +
}
   81     93   
impl GetAccessKeyLastUsedInput {
   82     94   
    /// Creates a new builder-style object to manufacture [`GetAccessKeyLastUsedInput`](crate::operation::get_access_key_last_used::GetAccessKeyLastUsedInput).
   83     95   
    pub fn builder() -> crate::operation::get_access_key_last_used::builders::GetAccessKeyLastUsedInputBuilder {
   84     96   
        crate::operation::get_access_key_last_used::builders::GetAccessKeyLastUsedInputBuilder::default()
   85     97   
    }
   86     98   
}
   87     99   
   88    100   
/// A builder for [`GetAccessKeyLastUsedInput`](crate::operation::get_access_key_last_used::GetAccessKeyLastUsedInput).
   89    101   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   90    102   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_access_key_last_used/_get_access_key_last_used_output.rs

@@ -7,7 +121,169 @@
   27     27   
    "com.amazonaws.iam.synthetic",
   28     28   
    "GetAccessKeyLastUsedOutput",
   29     29   
);
   30     30   
static GETACCESSKEYLASTUSEDOUTPUT_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static(
   32     32   
        "com.amazonaws.iam.synthetic#GetAccessKeyLastUsedOutput$UserName",
   33     33   
        "com.amazonaws.iam.synthetic",
   34     34   
        "GetAccessKeyLastUsedOutput",
   35     35   
    ),
   36     36   
    ::aws_smithy_schema::ShapeType::String,
   37         -
    "user_name",
          37  +
    "UserName",
   38     38   
    0,
   39     39   
);
   40     40   
static GETACCESSKEYLASTUSEDOUTPUT_MEMBER_ACCESS_KEY_LAST_USED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.iam.synthetic#GetAccessKeyLastUsedOutput$AccessKeyLastUsed",
   43     43   
        "com.amazonaws.iam.synthetic",
   44     44   
        "GetAccessKeyLastUsedOutput",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47         -
    "access_key_last_used",
          47  +
    "AccessKeyLastUsed",
   48     48   
    1,
   49     49   
);
          50  +
static GETACCESSKEYLASTUSEDOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          51  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          52  +
    ::aws_smithy_schema::ShapeType::String,
          53  +
    "request_id",
          54  +
    2,
          55  +
)
          56  +
.with_http_header("x-amzn-requestid");
   50     57   
static GETACCESSKEYLASTUSEDOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   51     58   
    GETACCESSKEYLASTUSEDOUTPUT_SCHEMA_ID,
   52     59   
    ::aws_smithy_schema::ShapeType::Structure,
   53     60   
    &[
   54     61   
        &GETACCESSKEYLASTUSEDOUTPUT_MEMBER_USER_NAME,
   55     62   
        &GETACCESSKEYLASTUSEDOUTPUT_MEMBER_ACCESS_KEY_LAST_USED,
          63  +
        &GETACCESSKEYLASTUSEDOUTPUT_MEMBER__REQUEST_ID,
   56     64   
    ],
   57     65   
);
   58     66   
impl GetAccessKeyLastUsedOutput {
   59     67   
    /// The schema for this shape.
   60     68   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETACCESSKEYLASTUSEDOUTPUT_SCHEMA;
   61     69   
}
   62     70   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAccessKeyLastUsedOutput {
   63     71   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   64     72   
    fn serialize_members(
   65     73   
        &self,
   66     74   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   67     75   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   68     76   
        if let Some(ref val) = self.user_name {
   69     77   
            ser.write_string(&GETACCESSKEYLASTUSEDOUTPUT_MEMBER_USER_NAME, val)?;
   70     78   
        }
   71     79   
        if let Some(ref val) = self.access_key_last_used {
   72     80   
            ser.write_struct(&GETACCESSKEYLASTUSEDOUTPUT_MEMBER_ACCESS_KEY_LAST_USED, val)?;
   73     81   
        }
   74     82   
        Ok(())
   75     83   
    }
   76     84   
}
   77     85   
impl GetAccessKeyLastUsedOutput {
   78     86   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   79         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   80         -
        deserializer: &mut D,
          87  +
    pub fn deserialize(
          88  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          89  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          90  +
        #[allow(unused_variables, unused_mut)]
          91  +
        let mut builder = Self::builder();
          92  +
        #[allow(
          93  +
            unused_variables,
          94  +
            unreachable_code,
          95  +
            clippy::single_match,
          96  +
            clippy::match_single_binding,
          97  +
            clippy::diverging_sub_expression
          98  +
        )]
          99  +
        deserializer.read_struct(&GETACCESSKEYLASTUSEDOUTPUT_SCHEMA, &mut |member, deser| {
         100  +
            match member.member_index() {
         101  +
                Some(0) => {
         102  +
                    builder.user_name = Some(deser.read_string(member)?);
         103  +
                }
         104  +
                Some(1) => {
         105  +
                    builder.access_key_last_used = Some(crate::types::AccessKeyLastUsed::deserialize(deser)?);
         106  +
                }
         107  +
                Some(2) => {
         108  +
                    builder._request_id = Some(deser.read_string(member)?);
         109  +
                }
         110  +
                _ => {}
         111  +
            }
         112  +
            Ok(())
         113  +
        })?;
         114  +
        Ok(builder.build())
         115  +
    }
         116  +
}
         117  +
impl GetAccessKeyLastUsedOutput {
         118  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         119  +
    /// Header-bound members are read directly from headers, avoiding runtime
         120  +
    /// member iteration overhead. Body members are read via the deserializer.
         121  +
    pub fn deserialize_with_response(
         122  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         123  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         124  +
        _status: u16,
         125  +
        _body: &[u8],
   81    126   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   82    127   
        #[allow(unused_variables, unused_mut)]
   83    128   
        let mut builder = Self::builder();
         129  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         130  +
            builder._request_id = Some(val.to_string());
         131  +
        }
   84    132   
        #[allow(
   85    133   
            unused_variables,
   86    134   
            unreachable_code,
   87    135   
            clippy::single_match,
   88    136   
            clippy::match_single_binding,
   89    137   
            clippy::diverging_sub_expression
   90    138   
        )]
   91         -
        deserializer.read_struct(&GETACCESSKEYLASTUSEDOUTPUT_SCHEMA, (), |_, member, deser| {
         139  +
        deserializer.read_struct(&GETACCESSKEYLASTUSEDOUTPUT_SCHEMA, &mut |member, deser| {
   92    140   
            match member.member_index() {
   93    141   
                Some(0) => {
   94    142   
                    builder.user_name = Some(deser.read_string(member)?);
   95    143   
                }
   96    144   
                Some(1) => {
   97    145   
                    builder.access_key_last_used = Some(crate::types::AccessKeyLastUsed::deserialize(deser)?);
   98    146   
                }
   99    147   
                _ => {}
  100    148   
            }
  101    149   
            Ok(())

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_account_authorization_details.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 `GetAccountAuthorizationDetails`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetAccountAuthorizationDetails;
    6      6   
impl GetAccountAuthorizationDetails {
    7      7   
    /// Creates a new `GetAccountAuthorizationDetails`
    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::get_account_authorization_details::GetAccountAuthorizationDetailsInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_account_authorization_details::GetAccountAuthorizationDetailsOutput::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::get_account_authorization_details::GetAccountAuthorizationDetailsInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_account_authorization_details::GetAccountAuthorizationDetailsOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_account_authorization_details::GetAccountAuthorizationDetailsError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +186,193 @@
  144    150   
                crate::operation::get_account_authorization_details::GetAccountAuthorizationDetailsError,
  145    151   
            >::new());
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct GetAccountAuthorizationDetailsResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetAccountAuthorizationDetailsResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159    166   
        let headers = response.headers();
  160    167   
        let body = response.body().bytes().expect("body loaded");
  161    168   
        #[allow(unused_mut)]
  162    169   
        let mut force_error = false;
  163    170   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164    171   
        let parse_result = if !success && status != 200 || force_error {
  165    172   
            crate::protocol_serde::shape_get_account_authorization_details::de_get_account_authorization_details_http_error(status, headers, body)
  166    173   
        } else {

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_account_authorization_details/_get_account_authorization_details_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_account_authorization_details/_get_account_authorization_details_output.rs

@@ -37,37 +159,167 @@
   57     57   
    "com.amazonaws.iam.synthetic",
   58     58   
    "GetAccountAuthorizationDetailsOutput",
   59     59   
);
   60     60   
static GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_USER_DETAIL_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.iam.synthetic#GetAccountAuthorizationDetailsOutput$UserDetailList",
   63     63   
        "com.amazonaws.iam.synthetic",
   64     64   
        "GetAccountAuthorizationDetailsOutput",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::List,
   67         -
    "user_detail_list",
          67  +
    "UserDetailList",
   68     68   
    0,
   69     69   
);
   70     70   
static GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_GROUP_DETAIL_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.iam.synthetic#GetAccountAuthorizationDetailsOutput$GroupDetailList",
   73     73   
        "com.amazonaws.iam.synthetic",
   74     74   
        "GetAccountAuthorizationDetailsOutput",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::List,
   77         -
    "group_detail_list",
          77  +
    "GroupDetailList",
   78     78   
    1,
   79     79   
);
   80     80   
static GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_ROLE_DETAIL_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.iam.synthetic#GetAccountAuthorizationDetailsOutput$RoleDetailList",
   83     83   
        "com.amazonaws.iam.synthetic",
   84     84   
        "GetAccountAuthorizationDetailsOutput",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::List,
   87         -
    "role_detail_list",
          87  +
    "RoleDetailList",
   88     88   
    2,
   89     89   
);
   90     90   
static GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_POLICIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.iam.synthetic#GetAccountAuthorizationDetailsOutput$Policies",
   93     93   
        "com.amazonaws.iam.synthetic",
   94     94   
        "GetAccountAuthorizationDetailsOutput",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::List,
   97         -
    "policies",
          97  +
    "Policies",
   98     98   
    3,
   99     99   
);
  100    100   
static GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_IS_TRUNCATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.iam.synthetic#GetAccountAuthorizationDetailsOutput$IsTruncated",
  103    103   
        "com.amazonaws.iam.synthetic",
  104    104   
        "GetAccountAuthorizationDetailsOutput",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::Boolean,
  107         -
    "is_truncated",
         107  +
    "IsTruncated",
  108    108   
    4,
  109    109   
);
  110    110   
static GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.iam.synthetic#GetAccountAuthorizationDetailsOutput$Marker",
  113    113   
        "com.amazonaws.iam.synthetic",
  114    114   
        "GetAccountAuthorizationDetailsOutput",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::String,
  117         -
    "marker",
         117  +
    "Marker",
  118    118   
    5,
  119    119   
);
         120  +
static GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         121  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         122  +
    ::aws_smithy_schema::ShapeType::String,
         123  +
    "request_id",
         124  +
    6,
         125  +
)
         126  +
.with_http_header("x-amzn-requestid");
  120    127   
static GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  121    128   
    GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_SCHEMA_ID,
  122    129   
    ::aws_smithy_schema::ShapeType::Structure,
  123    130   
    &[
  124    131   
        &GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_USER_DETAIL_LIST,
  125    132   
        &GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_GROUP_DETAIL_LIST,
  126    133   
        &GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_ROLE_DETAIL_LIST,
  127    134   
        &GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_POLICIES,
  128    135   
        &GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_IS_TRUNCATED,
  129    136   
        &GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_MARKER,
         137  +
        &GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER__REQUEST_ID,
  130    138   
    ],
  131    139   
);
  132    140   
impl GetAccountAuthorizationDetailsOutput {
  133    141   
    /// The schema for this shape.
  134    142   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_SCHEMA;
  135    143   
}
  136    144   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAccountAuthorizationDetailsOutput {
  137    145   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  138    146   
    fn serialize_members(
  139    147   
        &self,
@@ -168,176 +291,367 @@
  188    196   
            ser.write_boolean(&GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_IS_TRUNCATED, *val)?;
  189    197   
        }
  190    198   
        if let Some(ref val) = self.marker {
  191    199   
            ser.write_string(&GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_MEMBER_MARKER, val)?;
  192    200   
        }
  193    201   
        Ok(())
  194    202   
    }
  195    203   
}
  196    204   
impl GetAccountAuthorizationDetailsOutput {
  197    205   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  198         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  199         -
        deserializer: &mut D,
         206  +
    pub fn deserialize(
         207  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         208  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         209  +
        #[allow(unused_variables, unused_mut)]
         210  +
        let mut builder = Self::builder();
         211  +
        #[allow(
         212  +
            unused_variables,
         213  +
            unreachable_code,
         214  +
            clippy::single_match,
         215  +
            clippy::match_single_binding,
         216  +
            clippy::diverging_sub_expression
         217  +
        )]
         218  +
        deserializer.read_struct(&GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_SCHEMA, &mut |member, deser| {
         219  +
            match member.member_index() {
         220  +
                Some(0) => {
         221  +
                    builder.user_detail_list = Some({
         222  +
                        let mut container = Vec::new();
         223  +
                        deser.read_list(member, &mut |deser| {
         224  +
                            container.push(crate::types::UserDetail::deserialize(deser)?);
         225  +
                            Ok(())
         226  +
                        })?;
         227  +
                        container
         228  +
                    });
         229  +
                }
         230  +
                Some(1) => {
         231  +
                    builder.group_detail_list = Some({
         232  +
                        let mut container = Vec::new();
         233  +
                        deser.read_list(member, &mut |deser| {
         234  +
                            container.push(crate::types::GroupDetail::deserialize(deser)?);
         235  +
                            Ok(())
         236  +
                        })?;
         237  +
                        container
         238  +
                    });
         239  +
                }
         240  +
                Some(2) => {
         241  +
                    builder.role_detail_list = Some({
         242  +
                        let mut container = Vec::new();
         243  +
                        deser.read_list(member, &mut |deser| {
         244  +
                            container.push(crate::types::RoleDetail::deserialize(deser)?);
         245  +
                            Ok(())
         246  +
                        })?;
         247  +
                        container
         248  +
                    });
         249  +
                }
         250  +
                Some(3) => {
         251  +
                    builder.policies = Some({
         252  +
                        let mut container = Vec::new();
         253  +
                        deser.read_list(member, &mut |deser| {
         254  +
                            container.push(crate::types::ManagedPolicyDetail::deserialize(deser)?);
         255  +
                            Ok(())
         256  +
                        })?;
         257  +
                        container
         258  +
                    });
         259  +
                }
         260  +
                Some(4) => {
         261  +
                    builder.is_truncated = Some(deser.read_boolean(member)?);
         262  +
                }
         263  +
                Some(5) => {
         264  +
                    builder.marker = Some(deser.read_string(member)?);
         265  +
                }
         266  +
                Some(6) => {
         267  +
                    builder._request_id = Some(deser.read_string(member)?);
         268  +
                }
         269  +
                _ => {}
         270  +
            }
         271  +
            Ok(())
         272  +
        })?;
         273  +
        Ok(builder.build())
         274  +
    }
         275  +
}
         276  +
impl GetAccountAuthorizationDetailsOutput {
         277  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         278  +
    /// Header-bound members are read directly from headers, avoiding runtime
         279  +
    /// member iteration overhead. Body members are read via the deserializer.
         280  +
    pub fn deserialize_with_response(
         281  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         282  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         283  +
        _status: u16,
         284  +
        _body: &[u8],
  200    285   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  201    286   
        #[allow(unused_variables, unused_mut)]
  202    287   
        let mut builder = Self::builder();
         288  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         289  +
            builder._request_id = Some(val.to_string());
         290  +
        }
  203    291   
        #[allow(
  204    292   
            unused_variables,
  205    293   
            unreachable_code,
  206    294   
            clippy::single_match,
  207    295   
            clippy::match_single_binding,
  208    296   
            clippy::diverging_sub_expression
  209    297   
        )]
  210         -
        deserializer.read_struct(&GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_SCHEMA, (), |_, member, deser| {
         298  +
        deserializer.read_struct(&GETACCOUNTAUTHORIZATIONDETAILSOUTPUT_SCHEMA, &mut |member, deser| {
  211    299   
            match member.member_index() {
  212    300   
                Some(0) => {
  213    301   
                    builder.user_detail_list = Some({
  214         -
                        let container = if let Some(cap) = deser.container_size() {
  215         -
                            Vec::with_capacity(cap)
  216         -
                        } else {
  217         -
                            Vec::new()
  218         -
                        };
  219         -
                        deser.read_list(member, container, |mut list, deser| {
  220         -
                            list.push(crate::types::UserDetail::deserialize(deser)?);
  221         -
                            Ok(list)
  222         -
                        })?
         302  +
                        let mut container = Vec::new();
         303  +
                        deser.read_list(member, &mut |deser| {
         304  +
                            container.push(crate::types::UserDetail::deserialize(deser)?);
         305  +
                            Ok(())
         306  +
                        })?;
         307  +
                        container
  223    308   
                    });
  224    309   
                }
  225    310   
                Some(1) => {
  226    311   
                    builder.group_detail_list = Some({
  227         -
                        let container = if let Some(cap) = deser.container_size() {
  228         -
                            Vec::with_capacity(cap)
  229         -
                        } else {
  230         -
                            Vec::new()
  231         -
                        };
  232         -
                        deser.read_list(member, container, |mut list, deser| {
  233         -
                            list.push(crate::types::GroupDetail::deserialize(deser)?);
  234         -
                            Ok(list)
  235         -
                        })?
         312  +
                        let mut container = Vec::new();
         313  +
                        deser.read_list(member, &mut |deser| {
         314  +
                            container.push(crate::types::GroupDetail::deserialize(deser)?);
         315  +
                            Ok(())
         316  +
                        })?;
         317  +
                        container
  236    318   
                    });
  237    319   
                }
  238    320   
                Some(2) => {
  239    321   
                    builder.role_detail_list = Some({
  240         -
                        let container = if let Some(cap) = deser.container_size() {
  241         -
                            Vec::with_capacity(cap)
  242         -
                        } else {
  243         -
                            Vec::new()
  244         -
                        };
  245         -
                        deser.read_list(member, container, |mut list, deser| {
  246         -
                            list.push(crate::types::RoleDetail::deserialize(deser)?);
  247         -
                            Ok(list)
  248         -
                        })?
         322  +
                        let mut container = Vec::new();
         323  +
                        deser.read_list(member, &mut |deser| {
         324  +
                            container.push(crate::types::RoleDetail::deserialize(deser)?);
         325  +
                            Ok(())
         326  +
                        })?;
         327  +
                        container
  249    328   
                    });
  250    329   
                }
  251    330   
                Some(3) => {
  252    331   
                    builder.policies = Some({
  253         -
                        let container = if let Some(cap) = deser.container_size() {
  254         -
                            Vec::with_capacity(cap)
  255         -
                        } else {
  256         -
                            Vec::new()
  257         -
                        };
  258         -
                        deser.read_list(member, container, |mut list, deser| {
  259         -
                            list.push(crate::types::ManagedPolicyDetail::deserialize(deser)?);
  260         -
                            Ok(list)
  261         -
                        })?
         332  +
                        let mut container = Vec::new();
         333  +
                        deser.read_list(member, &mut |deser| {
         334  +
                            container.push(crate::types::ManagedPolicyDetail::deserialize(deser)?);
         335  +
                            Ok(())
         336  +
                        })?;
         337  +
                        container
  262    338   
                    });
  263    339   
                }
  264    340   
                Some(4) => {
  265    341   
                    builder.is_truncated = Some(deser.read_boolean(member)?);
  266    342   
                }
  267    343   
                Some(5) => {
  268    344   
                    builder.marker = Some(deser.read_string(member)?);
  269    345   
                }
  270    346   
                _ => {}
  271    347   
            }

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_account_password_policy/_get_account_password_policy_input.rs

@@ -1,1 +72,85 @@
   18     18   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   19     19   
    fn serialize_members(
   20     20   
        &self,
   21     21   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   22     22   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   23     23   
        Ok(())
   24     24   
    }
   25     25   
}
   26     26   
impl GetAccountPasswordPolicyInput {
   27     27   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   28         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   29         -
        deserializer: &mut D,
          28  +
    pub fn deserialize(
          29  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   30     30   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   31     31   
        #[allow(unused_variables, unused_mut)]
   32     32   
        let mut builder = Self::builder();
   33     33   
        #[allow(
   34     34   
            unused_variables,
   35     35   
            unreachable_code,
   36     36   
            clippy::single_match,
   37     37   
            clippy::match_single_binding,
   38     38   
            clippy::diverging_sub_expression
   39     39   
        )]
   40         -
        deserializer.read_struct(&GETACCOUNTPASSWORDPOLICYINPUT_SCHEMA, (), |_, member, deser| {
          40  +
        deserializer.read_struct(&GETACCOUNTPASSWORDPOLICYINPUT_SCHEMA, &mut |member, deser| {
   41     41   
            match member.member_index() {
   42     42   
                _ => {}
   43     43   
            }
   44     44   
            Ok(())
   45     45   
        })?;
   46     46   
        builder
   47     47   
            .build()
   48     48   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   49     49   
    }
   50     50   
}
          51  +
impl GetAccountPasswordPolicyInput {
          52  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          53  +
    pub fn deserialize_with_response(
          54  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          55  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          56  +
        _status: u16,
          57  +
        _body: &[u8],
          58  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          59  +
        Self::builder()
          60  +
            .build()
          61  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
          62  +
    }
          63  +
}
   51     64   
impl GetAccountPasswordPolicyInput {
   52     65   
    /// Creates a new builder-style object to manufacture [`GetAccountPasswordPolicyInput`](crate::operation::get_account_password_policy::GetAccountPasswordPolicyInput).
   53     66   
    pub fn builder() -> crate::operation::get_account_password_policy::builders::GetAccountPasswordPolicyInputBuilder {
   54     67   
        crate::operation::get_account_password_policy::builders::GetAccountPasswordPolicyInputBuilder::default()
   55     68   
    }
   56     69   
}
   57     70   
   58     71   
/// A builder for [`GetAccountPasswordPolicyInput`](crate::operation::get_account_password_policy::GetAccountPasswordPolicyInput).
   59     72   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   60     73   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_account_password_policy/_get_account_password_policy_output.rs

@@ -1,1 +97,144 @@
   19     19   
    "com.amazonaws.iam.synthetic",
   20     20   
    "GetAccountPasswordPolicyOutput",
   21     21   
);
   22     22   
static GETACCOUNTPASSWORDPOLICYOUTPUT_MEMBER_PASSWORD_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.iam.synthetic#GetAccountPasswordPolicyOutput$PasswordPolicy",
   25     25   
        "com.amazonaws.iam.synthetic",
   26     26   
        "GetAccountPasswordPolicyOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29         -
    "password_policy",
          29  +
    "PasswordPolicy",
   30     30   
    0,
   31     31   
);
          32  +
static GETACCOUNTPASSWORDPOLICYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          33  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          34  +
    ::aws_smithy_schema::ShapeType::String,
          35  +
    "request_id",
          36  +
    1,
          37  +
)
          38  +
.with_http_header("x-amzn-requestid");
   32     39   
static GETACCOUNTPASSWORDPOLICYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    GETACCOUNTPASSWORDPOLICYOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&GETACCOUNTPASSWORDPOLICYOUTPUT_MEMBER_PASSWORD_POLICY],
          42  +
    &[
          43  +
        &GETACCOUNTPASSWORDPOLICYOUTPUT_MEMBER_PASSWORD_POLICY,
          44  +
        &GETACCOUNTPASSWORDPOLICYOUTPUT_MEMBER__REQUEST_ID,
          45  +
    ],
   36     46   
);
   37     47   
impl GetAccountPasswordPolicyOutput {
   38     48   
    /// The schema for this shape.
   39     49   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETACCOUNTPASSWORDPOLICYOUTPUT_SCHEMA;
   40     50   
}
   41     51   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAccountPasswordPolicyOutput {
   42     52   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     53   
    fn serialize_members(
   44     54   
        &self,
   45     55   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     56   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     57   
        if let Some(ref val) = self.password_policy {
   48     58   
            ser.write_struct(&GETACCOUNTPASSWORDPOLICYOUTPUT_MEMBER_PASSWORD_POLICY, val)?;
   49     59   
        }
   50     60   
        Ok(())
   51     61   
    }
   52     62   
}
   53     63   
impl GetAccountPasswordPolicyOutput {
   54     64   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   55         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   56         -
        deserializer: &mut D,
          65  +
    pub fn deserialize(
          66  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   57     67   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   58     68   
        #[allow(unused_variables, unused_mut)]
   59     69   
        let mut builder = Self::builder();
   60     70   
        #[allow(
   61     71   
            unused_variables,
   62     72   
            unreachable_code,
   63     73   
            clippy::single_match,
   64     74   
            clippy::match_single_binding,
   65     75   
            clippy::diverging_sub_expression
   66     76   
        )]
   67         -
        deserializer.read_struct(&GETACCOUNTPASSWORDPOLICYOUTPUT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&GETACCOUNTPASSWORDPOLICYOUTPUT_SCHEMA, &mut |member, deser| {
          78  +
            match member.member_index() {
          79  +
                Some(0) => {
          80  +
                    builder.password_policy = Some(crate::types::PasswordPolicy::deserialize(deser)?);
          81  +
                }
          82  +
                Some(1) => {
          83  +
                    builder._request_id = Some(deser.read_string(member)?);
          84  +
                }
          85  +
                _ => {}
          86  +
            }
          87  +
            Ok(())
          88  +
        })?;
          89  +
        Ok(builder.build())
          90  +
    }
          91  +
}
          92  +
impl GetAccountPasswordPolicyOutput {
          93  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          94  +
    /// Header-bound members are read directly from headers, avoiding runtime
          95  +
    /// member iteration overhead. Body members are read via the deserializer.
          96  +
    pub fn deserialize_with_response(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          98  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          99  +
        _status: u16,
         100  +
        _body: &[u8],
         101  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         102  +
        #[allow(unused_variables, unused_mut)]
         103  +
        let mut builder = Self::builder();
         104  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         105  +
            builder._request_id = Some(val.to_string());
         106  +
        }
         107  +
        #[allow(
         108  +
            unused_variables,
         109  +
            unreachable_code,
         110  +
            clippy::single_match,
         111  +
            clippy::match_single_binding,
         112  +
            clippy::diverging_sub_expression
         113  +
        )]
         114  +
        deserializer.read_struct(&GETACCOUNTPASSWORDPOLICYOUTPUT_SCHEMA, &mut |member, deser| {
   68    115   
            match member.member_index() {
   69    116   
                Some(0) => {
   70    117   
                    builder.password_policy = Some(crate::types::PasswordPolicy::deserialize(deser)?);
   71    118   
                }
   72    119   
                _ => {}
   73    120   
            }
   74    121   
            Ok(())
   75    122   
        })?;
   76    123   
        Ok(builder.build())
   77    124   
    }

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_account_summary/_get_account_summary_input.rs

@@ -1,1 +69,82 @@
   18     18   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   19     19   
    fn serialize_members(
   20     20   
        &self,
   21     21   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   22     22   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   23     23   
        Ok(())
   24     24   
    }
   25     25   
}
   26     26   
impl GetAccountSummaryInput {
   27     27   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   28         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   29         -
        deserializer: &mut D,
          28  +
    pub fn deserialize(
          29  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   30     30   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   31     31   
        #[allow(unused_variables, unused_mut)]
   32     32   
        let mut builder = Self::builder();
   33     33   
        #[allow(
   34     34   
            unused_variables,
   35     35   
            unreachable_code,
   36     36   
            clippy::single_match,
   37     37   
            clippy::match_single_binding,
   38     38   
            clippy::diverging_sub_expression
   39     39   
        )]
   40         -
        deserializer.read_struct(&GETACCOUNTSUMMARYINPUT_SCHEMA, (), |_, member, deser| {
          40  +
        deserializer.read_struct(&GETACCOUNTSUMMARYINPUT_SCHEMA, &mut |member, deser| {
   41     41   
            match member.member_index() {
   42     42   
                _ => {}
   43     43   
            }
   44     44   
            Ok(())
   45     45   
        })?;
   46     46   
        builder
   47     47   
            .build()
   48     48   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   49     49   
    }
   50     50   
}
          51  +
impl GetAccountSummaryInput {
          52  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          53  +
    pub fn deserialize_with_response(
          54  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          55  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          56  +
        _status: u16,
          57  +
        _body: &[u8],
          58  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          59  +
        Self::builder()
          60  +
            .build()
          61  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
          62  +
    }
          63  +
}
   51     64   
impl GetAccountSummaryInput {
   52     65   
    /// Creates a new builder-style object to manufacture [`GetAccountSummaryInput`](crate::operation::get_account_summary::GetAccountSummaryInput).
   53     66   
    pub fn builder() -> crate::operation::get_account_summary::builders::GetAccountSummaryInputBuilder {
   54     67   
        crate::operation::get_account_summary::builders::GetAccountSummaryInputBuilder::default()
   55     68   
    }
   56     69   
}
   57     70   
   58     71   
/// A builder for [`GetAccountSummaryInput`](crate::operation::get_account_summary::GetAccountSummaryInput).
   59     72   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   60     73   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_account_summary/_get_account_summary_output.rs

@@ -1,1 +118,166 @@
   19     19   
    "com.amazonaws.iam.synthetic",
   20     20   
    "GetAccountSummaryOutput",
   21     21   
);
   22     22   
static GETACCOUNTSUMMARYOUTPUT_MEMBER_SUMMARY_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.iam.synthetic#GetAccountSummaryOutput$SummaryMap",
   25     25   
        "com.amazonaws.iam.synthetic",
   26     26   
        "GetAccountSummaryOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::Map,
   29         -
    "summary_map",
          29  +
    "SummaryMap",
   30     30   
    0,
   31     31   
);
          32  +
static GETACCOUNTSUMMARYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          33  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          34  +
    ::aws_smithy_schema::ShapeType::String,
          35  +
    "request_id",
          36  +
    1,
          37  +
)
          38  +
.with_http_header("x-amzn-requestid");
   32     39   
static GETACCOUNTSUMMARYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     40   
    GETACCOUNTSUMMARYOUTPUT_SCHEMA_ID,
   34     41   
    ::aws_smithy_schema::ShapeType::Structure,
   35         -
    &[&GETACCOUNTSUMMARYOUTPUT_MEMBER_SUMMARY_MAP],
          42  +
    &[&GETACCOUNTSUMMARYOUTPUT_MEMBER_SUMMARY_MAP, &GETACCOUNTSUMMARYOUTPUT_MEMBER__REQUEST_ID],
   36     43   
);
   37     44   
impl GetAccountSummaryOutput {
   38     45   
    /// The schema for this shape.
   39     46   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETACCOUNTSUMMARYOUTPUT_SCHEMA;
   40     47   
}
   41     48   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAccountSummaryOutput {
   42     49   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   43     50   
    fn serialize_members(
   44     51   
        &self,
   45     52   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   46     53   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   47     54   
        if let Some(ref val) = self.summary_map {
   48     55   
            ser.write_map(
   49     56   
                &GETACCOUNTSUMMARYOUTPUT_MEMBER_SUMMARY_MAP,
   50     57   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   51     58   
                    for (key, value) in val {
   52     59   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key.as_str())?;
   53     60   
                        ser.write_integer(&::aws_smithy_schema::prelude::INTEGER, *value)?;
   54     61   
                    }
   55     62   
                    Ok(())
   56     63   
                },
   57     64   
            )?;
   58     65   
        }
   59     66   
        Ok(())
   60     67   
    }
   61     68   
}
   62     69   
impl GetAccountSummaryOutput {
   63     70   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          71  +
    pub fn deserialize(
          72  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     73   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     74   
        #[allow(unused_variables, unused_mut)]
   68     75   
        let mut builder = Self::builder();
   69     76   
        #[allow(
   70     77   
            unused_variables,
   71     78   
            unreachable_code,
   72     79   
            clippy::single_match,
   73     80   
            clippy::match_single_binding,
   74     81   
            clippy::diverging_sub_expression
   75     82   
        )]
   76         -
        deserializer.read_struct(&GETACCOUNTSUMMARYOUTPUT_SCHEMA, (), |_, member, deser| {
          83  +
        deserializer.read_struct(&GETACCOUNTSUMMARYOUTPUT_SCHEMA, &mut |member, deser| {
   77     84   
            match member.member_index() {
   78     85   
                Some(0) => {
   79     86   
                    builder.summary_map = Some({
   80         -
                        let container = if let Some(cap) = deser.container_size() {
   81         -
                            std::collections::HashMap::with_capacity(cap)
   82         -
                        } else {
   83         -
                            std::collections::HashMap::new()
   84         -
                        };
   85         -
                        deser.read_map(member, container, |mut map, key, deser| {
   86         -
                            map.insert(crate::types::SummaryKeyType::from(key.as_str()), deser.read_integer(member)?);
   87         -
                            Ok(map)
   88         -
                        })?
          87  +
                        let mut container = std::collections::HashMap::new();
          88  +
                        deser.read_map(member, &mut |key, deser| {
          89  +
                            container.insert(crate::types::SummaryKeyType::from(key.as_str()), deser.read_integer(member)?);
          90  +
                            Ok(())
          91  +
                        })?;
          92  +
                        container
          93  +
                    });
          94  +
                }
          95  +
                Some(1) => {
          96  +
                    builder._request_id = Some(deser.read_string(member)?);
          97  +
                }
          98  +
                _ => {}
          99  +
            }
         100  +
            Ok(())
         101  +
        })?;
         102  +
        Ok(builder.build())
         103  +
    }
         104  +
}
         105  +
impl GetAccountSummaryOutput {
         106  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         107  +
    /// Header-bound members are read directly from headers, avoiding runtime
         108  +
    /// member iteration overhead. Body members are read via the deserializer.
         109  +
    pub fn deserialize_with_response(
         110  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         111  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         112  +
        _status: u16,
         113  +
        _body: &[u8],
         114  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         115  +
        #[allow(unused_variables, unused_mut)]
         116  +
        let mut builder = Self::builder();
         117  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         118  +
            builder._request_id = Some(val.to_string());
         119  +
        }
         120  +
        #[allow(
         121  +
            unused_variables,
         122  +
            unreachable_code,
         123  +
            clippy::single_match,
         124  +
            clippy::match_single_binding,
         125  +
            clippy::diverging_sub_expression
         126  +
        )]
         127  +
        deserializer.read_struct(&GETACCOUNTSUMMARYOUTPUT_SCHEMA, &mut |member, deser| {
         128  +
            match member.member_index() {
         129  +
                Some(0) => {
         130  +
                    builder.summary_map = Some({
         131  +
                        let mut container = std::collections::HashMap::new();
         132  +
                        deser.read_map(member, &mut |key, deser| {
         133  +
                            container.insert(crate::types::SummaryKeyType::from(key.as_str()), deser.read_integer(member)?);
         134  +
                            Ok(())
         135  +
                        })?;
         136  +
                        container
   89    137   
                    });
   90    138   
                }
   91    139   
                _ => {}
   92    140   
            }
   93    141   
            Ok(())
   94    142   
        })?;
   95    143   
        Ok(builder.build())
   96    144   
    }
   97    145   
}
   98    146   
impl ::aws_types::request_id::RequestId for GetAccountSummaryOutput {

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_context_keys_for_custom_policy/_get_context_keys_for_custom_policy_input.rs

@@ -17,17 +146,148 @@
   37     37   
    "com.amazonaws.iam.synthetic",
   38     38   
    "GetContextKeysForCustomPolicyInput",
   39     39   
);
   40     40   
static GETCONTEXTKEYSFORCUSTOMPOLICYINPUT_MEMBER_POLICY_INPUT_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.iam.synthetic#GetContextKeysForCustomPolicyInput$PolicyInputList",
   43     43   
        "com.amazonaws.iam.synthetic",
   44     44   
        "GetContextKeysForCustomPolicyInput",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::List,
   47         -
    "policy_input_list",
          47  +
    "PolicyInputList",
   48     48   
    0,
   49     49   
);
   50     50   
static GETCONTEXTKEYSFORCUSTOMPOLICYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   51     51   
    GETCONTEXTKEYSFORCUSTOMPOLICYINPUT_SCHEMA_ID,
   52     52   
    ::aws_smithy_schema::ShapeType::Structure,
   53     53   
    &[&GETCONTEXTKEYSFORCUSTOMPOLICYINPUT_MEMBER_POLICY_INPUT_LIST],
   54     54   
);
   55     55   
impl GetContextKeysForCustomPolicyInput {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETCONTEXTKEYSFORCUSTOMPOLICYINPUT_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for GetContextKeysForCustomPolicyInput {
   60     60   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   61     61   
    fn serialize_members(
   62     62   
        &self,
   63     63   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   64     64   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        if let Some(ref val) = self.policy_input_list {
   66     66   
            ser.write_list(
   67     67   
                &GETCONTEXTKEYSFORCUSTOMPOLICYINPUT_MEMBER_POLICY_INPUT_LIST,
   68     68   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   69     69   
                    for item in val {
   70     70   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   71     71   
                    }
   72     72   
                    Ok(())
   73     73   
                },
   74     74   
            )?;
   75     75   
        }
   76     76   
        Ok(())
   77     77   
    }
   78     78   
}
   79     79   
impl GetContextKeysForCustomPolicyInput {
   80     80   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   81         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   82         -
        deserializer: &mut D,
          81  +
    pub fn deserialize(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   83     83   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        #[allow(unused_variables, unused_mut)]
   85     85   
        let mut builder = Self::builder();
   86     86   
        #[allow(
   87     87   
            unused_variables,
   88     88   
            unreachable_code,
   89     89   
            clippy::single_match,
   90     90   
            clippy::match_single_binding,
   91     91   
            clippy::diverging_sub_expression
   92     92   
        )]
   93         -
        deserializer.read_struct(&GETCONTEXTKEYSFORCUSTOMPOLICYINPUT_SCHEMA, (), |_, member, deser| {
          93  +
        deserializer.read_struct(&GETCONTEXTKEYSFORCUSTOMPOLICYINPUT_SCHEMA, &mut |member, deser| {
   94     94   
            match member.member_index() {
   95     95   
                Some(0) => {
   96         -
                    builder.policy_input_list = Some({
   97         -
                        let container = if let Some(cap) = deser.container_size() {
   98         -
                            Vec::with_capacity(cap)
   99         -
                        } else {
  100         -
                            Vec::new()
  101         -
                        };
  102         -
                        deser.read_list(member, container, |mut list, deser| {
  103         -
                            list.push(deser.read_string(member)?);
  104         -
                            Ok(list)
  105         -
                        })?
  106         -
                    });
          96  +
                    builder.policy_input_list = Some(deser.read_string_list(member)?);
  107     97   
                }
  108     98   
                _ => {}
  109     99   
            }
  110    100   
            Ok(())
  111    101   
        })?;
         102  +
        builder.policy_input_list = builder.policy_input_list.or(Some(Vec::new()));
  112    103   
        builder
  113    104   
            .build()
  114    105   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  115    106   
    }
  116    107   
}
         108  +
impl GetContextKeysForCustomPolicyInput {
         109  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         110  +
    pub fn deserialize_with_response(
         111  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         112  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         113  +
        _status: u16,
         114  +
        _body: &[u8],
         115  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         116  +
        Self::deserialize(deserializer)
         117  +
    }
         118  +
}
  117    119   
impl GetContextKeysForCustomPolicyInput {
  118    120   
    /// Creates a new builder-style object to manufacture [`GetContextKeysForCustomPolicyInput`](crate::operation::get_context_keys_for_custom_policy::GetContextKeysForCustomPolicyInput).
  119    121   
    pub fn builder() -> crate::operation::get_context_keys_for_custom_policy::builders::GetContextKeysForCustomPolicyInputBuilder {
  120    122   
        crate::operation::get_context_keys_for_custom_policy::builders::GetContextKeysForCustomPolicyInputBuilder::default()
  121    123   
    }
  122    124   
}
  123    125   
  124    126   
/// A builder for [`GetContextKeysForCustomPolicyInput`](crate::operation::get_context_keys_for_custom_policy::GetContextKeysForCustomPolicyInput).
  125    127   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  126    128   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_context_keys_for_custom_policy/_get_context_keys_for_custom_policy_output.rs

@@ -1,1 +120,157 @@
   21     21   
    "com.amazonaws.iam.synthetic",
   22     22   
    "GetContextKeysForCustomPolicyOutput",
   23     23   
);
   24     24   
static GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_MEMBER_CONTEXT_KEY_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.iam.synthetic#GetContextKeysForCustomPolicyOutput$ContextKeyNames",
   27     27   
        "com.amazonaws.iam.synthetic",
   28     28   
        "GetContextKeysForCustomPolicyOutput",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::List,
   31         -
    "context_key_names",
          31  +
    "ContextKeyNames",
   32     32   
    0,
   33     33   
);
          34  +
static GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          35  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          36  +
    ::aws_smithy_schema::ShapeType::String,
          37  +
    "request_id",
          38  +
    1,
          39  +
)
          40  +
.with_http_header("x-amzn-requestid");
   34     41   
static GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   35     42   
    GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_SCHEMA_ID,
   36     43   
    ::aws_smithy_schema::ShapeType::Structure,
   37         -
    &[&GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_MEMBER_CONTEXT_KEY_NAMES],
          44  +
    &[
          45  +
        &GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_MEMBER_CONTEXT_KEY_NAMES,
          46  +
        &GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_MEMBER__REQUEST_ID,
          47  +
    ],
   38     48   
);
   39     49   
impl GetContextKeysForCustomPolicyOutput {
   40     50   
    /// The schema for this shape.
   41     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_SCHEMA;
   42     52   
}
   43     53   
impl ::aws_smithy_schema::serde::SerializableStruct for GetContextKeysForCustomPolicyOutput {
   44     54   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   45     55   
    fn serialize_members(
   46     56   
        &self,
   47     57   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   48     58   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   49     59   
        if let Some(ref val) = self.context_key_names {
   50     60   
            ser.write_list(
   51     61   
                &GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_MEMBER_CONTEXT_KEY_NAMES,
   52     62   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   53     63   
                    for item in val {
   54     64   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   55     65   
                    }
   56     66   
                    Ok(())
   57     67   
                },
   58     68   
            )?;
   59     69   
        }
   60     70   
        Ok(())
   61     71   
    }
   62     72   
}
   63     73   
impl GetContextKeysForCustomPolicyOutput {
   64     74   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   65         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   66         -
        deserializer: &mut D,
          75  +
    pub fn deserialize(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          78  +
        #[allow(unused_variables, unused_mut)]
          79  +
        let mut builder = Self::builder();
          80  +
        #[allow(
          81  +
            unused_variables,
          82  +
            unreachable_code,
          83  +
            clippy::single_match,
          84  +
            clippy::match_single_binding,
          85  +
            clippy::diverging_sub_expression
          86  +
        )]
          87  +
        deserializer.read_struct(&GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_SCHEMA, &mut |member, deser| {
          88  +
            match member.member_index() {
          89  +
                Some(0) => {
          90  +
                    builder.context_key_names = Some(deser.read_string_list(member)?);
          91  +
                }
          92  +
                Some(1) => {
          93  +
                    builder._request_id = Some(deser.read_string(member)?);
          94  +
                }
          95  +
                _ => {}
          96  +
            }
          97  +
            Ok(())
          98  +
        })?;
          99  +
        Ok(builder.build())
         100  +
    }
         101  +
}
         102  +
impl GetContextKeysForCustomPolicyOutput {
         103  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         104  +
    /// Header-bound members are read directly from headers, avoiding runtime
         105  +
    /// member iteration overhead. Body members are read via the deserializer.
         106  +
    pub fn deserialize_with_response(
         107  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         108  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         109  +
        _status: u16,
         110  +
        _body: &[u8],
   67    111   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   68    112   
        #[allow(unused_variables, unused_mut)]
   69    113   
        let mut builder = Self::builder();
         114  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         115  +
            builder._request_id = Some(val.to_string());
         116  +
        }
   70    117   
        #[allow(
   71    118   
            unused_variables,
   72    119   
            unreachable_code,
   73    120   
            clippy::single_match,
   74    121   
            clippy::match_single_binding,
   75    122   
            clippy::diverging_sub_expression
   76    123   
        )]
   77         -
        deserializer.read_struct(&GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_SCHEMA, (), |_, member, deser| {
         124  +
        deserializer.read_struct(&GETCONTEXTKEYSFORCUSTOMPOLICYOUTPUT_SCHEMA, &mut |member, deser| {
   78    125   
            match member.member_index() {
   79    126   
                Some(0) => {
   80         -
                    builder.context_key_names = Some({
   81         -
                        let container = if let Some(cap) = deser.container_size() {
   82         -
                            Vec::with_capacity(cap)
   83         -
                        } else {
   84         -
                            Vec::new()
   85         -
                        };
   86         -
                        deser.read_list(member, container, |mut list, deser| {
   87         -
                            list.push(deser.read_string(member)?);
   88         -
                            Ok(list)
   89         -
                        })?
   90         -
                    });
         127  +
                    builder.context_key_names = Some(deser.read_string_list(member)?);
   91    128   
                }
   92    129   
                _ => {}
   93    130   
            }
   94    131   
            Ok(())
   95    132   
        })?;
   96    133   
        Ok(builder.build())
   97    134   
    }
   98    135   
}
   99    136   
impl ::aws_types::request_id::RequestId for GetContextKeysForCustomPolicyOutput {
  100    137   
    fn request_id(&self) -> Option<&str> {

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_context_keys_for_principal_policy.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 `GetContextKeysForPrincipalPolicy`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetContextKeysForPrincipalPolicy;
    6      6   
impl GetContextKeysForPrincipalPolicy {
    7      7   
    /// Creates a new `GetContextKeysForPrincipalPolicy`
    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::get_context_keys_for_principal_policy::GetContextKeysForPrincipalPolicyInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_context_keys_for_principal_policy::GetContextKeysForPrincipalPolicyOutput::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::get_context_keys_for_principal_policy::GetContextKeysForPrincipalPolicyInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_context_keys_for_principal_policy::GetContextKeysForPrincipalPolicyOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_context_keys_for_principal_policy::GetContextKeysForPrincipalPolicyError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +186,193 @@
  144    150   
                crate::operation::get_context_keys_for_principal_policy::GetContextKeysForPrincipalPolicyError,
  145    151   
            >::new());
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct GetContextKeysForPrincipalPolicyResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetContextKeysForPrincipalPolicyResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159    166   
        let headers = response.headers();
  160    167   
        let body = response.body().bytes().expect("body loaded");
  161    168   
        #[allow(unused_mut)]
  162    169   
        let mut force_error = false;
  163    170   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164    171   
        let parse_result = if !success && status != 200 || force_error {
  165    172   
            crate::protocol_serde::shape_get_context_keys_for_principal_policy::de_get_context_keys_for_principal_policy_http_error(
  166    173   
                status, headers, body,

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_context_keys_for_principal_policy/_get_context_keys_for_principal_policy_input.rs

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