AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_group_detail.rs

@@ -34,34 +134,134 @@
   54     54   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.attached_managed_policies.is_none()`.
   55     55   
    pub fn attached_managed_policies(&self) -> &[crate::types::AttachedPolicy] {
   56     56   
        self.attached_managed_policies.as_deref().unwrap_or_default()
   57     57   
    }
   58     58   
}
   59     59   
static GROUPDETAIL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   60     60   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#GroupDetail", "com.amazonaws.iam", "GroupDetail");
   61     61   
static GROUPDETAIL_MEMBER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#GroupDetail$Path", "com.amazonaws.iam", "GroupDetail"),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "path",
          64  +
    "Path",
   65     65   
    0,
   66     66   
);
   67     67   
static GROUPDETAIL_MEMBER_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#GroupDetail$GroupName", "com.amazonaws.iam", "GroupDetail"),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "group_name",
          70  +
    "GroupName",
   71     71   
    1,
   72     72   
);
   73     73   
static GROUPDETAIL_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#GroupDetail$GroupId", "com.amazonaws.iam", "GroupDetail"),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "group_id",
          76  +
    "GroupId",
   77     77   
    2,
   78     78   
);
   79     79   
static GROUPDETAIL_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#GroupDetail$Arn", "com.amazonaws.iam", "GroupDetail"),
   81     81   
    ::aws_smithy_schema::ShapeType::String,
   82         -
    "arn",
          82  +
    "Arn",
   83     83   
    3,
   84     84   
);
   85     85   
static GROUPDETAIL_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#GroupDetail$CreateDate", "com.amazonaws.iam", "GroupDetail"),
   87     87   
    ::aws_smithy_schema::ShapeType::Timestamp,
   88         -
    "create_date",
          88  +
    "CreateDate",
   89     89   
    4,
   90     90   
);
   91     91   
static GROUPDETAIL_MEMBER_GROUP_POLICY_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#GroupDetail$GroupPolicyList", "com.amazonaws.iam", "GroupDetail"),
   93     93   
    ::aws_smithy_schema::ShapeType::List,
   94         -
    "group_policy_list",
          94  +
    "GroupPolicyList",
   95     95   
    5,
   96     96   
);
   97     97   
static GROUPDETAIL_MEMBER_ATTACHED_MANAGED_POLICIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.iam#GroupDetail$AttachedManagedPolicies",
  100    100   
        "com.amazonaws.iam",
  101    101   
        "GroupDetail",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::List,
  104         -
    "attached_managed_policies",
         104  +
    "AttachedManagedPolicies",
  105    105   
    6,
  106    106   
);
  107    107   
static GROUPDETAIL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  108    108   
    GROUPDETAIL_SCHEMA_ID,
  109    109   
    ::aws_smithy_schema::ShapeType::Structure,
  110    110   
    &[
  111    111   
        &GROUPDETAIL_MEMBER_PATH,
  112    112   
        &GROUPDETAIL_MEMBER_GROUP_NAME,
  113    113   
        &GROUPDETAIL_MEMBER_GROUP_ID,
  114    114   
        &GROUPDETAIL_MEMBER_ARN,
@@ -142,142 +263,268 @@
  162    162   
                    }
  163    163   
                    Ok(())
  164    164   
                },
  165    165   
            )?;
  166    166   
        }
  167    167   
        Ok(())
  168    168   
    }
  169    169   
}
  170    170   
impl GroupDetail {
  171    171   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  172         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  173         -
        deserializer: &mut D,
         172  +
    pub fn deserialize(
         173  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  174    174   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  175    175   
        #[allow(unused_variables, unused_mut)]
  176    176   
        let mut builder = Self::builder();
  177    177   
        #[allow(
  178    178   
            unused_variables,
  179    179   
            unreachable_code,
  180    180   
            clippy::single_match,
  181    181   
            clippy::match_single_binding,
  182    182   
            clippy::diverging_sub_expression
  183    183   
        )]
  184         -
        deserializer.read_struct(&GROUPDETAIL_SCHEMA, (), |_, member, deser| {
         184  +
        deserializer.read_struct(&GROUPDETAIL_SCHEMA, &mut |member, deser| {
  185    185   
            match member.member_index() {
  186    186   
                Some(0) => {
  187    187   
                    builder.path = Some(deser.read_string(member)?);
  188    188   
                }
  189    189   
                Some(1) => {
  190    190   
                    builder.group_name = Some(deser.read_string(member)?);
  191    191   
                }
  192    192   
                Some(2) => {
  193    193   
                    builder.group_id = Some(deser.read_string(member)?);
  194    194   
                }
  195    195   
                Some(3) => {
  196    196   
                    builder.arn = Some(deser.read_string(member)?);
  197    197   
                }
  198    198   
                Some(4) => {
  199    199   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  200    200   
                }
  201    201   
                Some(5) => {
  202    202   
                    builder.group_policy_list = Some({
  203         -
                        let container = if let Some(cap) = deser.container_size() {
  204         -
                            Vec::with_capacity(cap)
  205         -
                        } else {
  206         -
                            Vec::new()
  207         -
                        };
  208         -
                        deser.read_list(member, container, |mut list, deser| {
  209         -
                            list.push(crate::types::PolicyDetail::deserialize(deser)?);
  210         -
                            Ok(list)
  211         -
                        })?
         203  +
                        let mut container = Vec::new();
         204  +
                        deser.read_list(member, &mut |deser| {
         205  +
                            container.push(crate::types::PolicyDetail::deserialize(deser)?);
         206  +
                            Ok(())
         207  +
                        })?;
         208  +
                        container
  212    209   
                    });
  213    210   
                }
  214    211   
                Some(6) => {
  215    212   
                    builder.attached_managed_policies = Some({
  216         -
                        let container = if let Some(cap) = deser.container_size() {
  217         -
                            Vec::with_capacity(cap)
  218         -
                        } else {
  219         -
                            Vec::new()
  220         -
                        };
  221         -
                        deser.read_list(member, container, |mut list, deser| {
  222         -
                            list.push(crate::types::AttachedPolicy::deserialize(deser)?);
  223         -
                            Ok(list)
  224         -
                        })?
         213  +
                        let mut container = Vec::new();
         214  +
                        deser.read_list(member, &mut |deser| {
         215  +
                            container.push(crate::types::AttachedPolicy::deserialize(deser)?);
         216  +
                            Ok(())
         217  +
                        })?;
         218  +
                        container
  225    219   
                    });
  226    220   
                }
  227    221   
                _ => {}
  228    222   
            }
  229    223   
            Ok(())
  230    224   
        })?;
  231    225   
        Ok(builder.build())
  232    226   
    }
  233    227   
}
         228  +
impl GroupDetail {
         229  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         230  +
    pub fn deserialize_with_response(
         231  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         232  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         233  +
        _status: u16,
         234  +
        _body: &[u8],
         235  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         236  +
        Self::deserialize(deserializer)
         237  +
    }
         238  +
}
  234    239   
impl GroupDetail {
  235    240   
    /// Creates a new builder-style object to manufacture [`GroupDetail`](crate::types::GroupDetail).
  236    241   
    pub fn builder() -> crate::types::builders::GroupDetailBuilder {
  237    242   
        crate::types::builders::GroupDetailBuilder::default()
  238    243   
    }
  239    244   
}
  240    245   
  241    246   
/// A builder for [`GroupDetail`](crate::types::GroupDetail).
  242    247   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  243    248   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_instance_profile.rs

@@ -45,45 +149,149 @@
   65     65   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   66     66   
    pub fn tags(&self) -> &[crate::types::Tag] {
   67     67   
        self.tags.as_deref().unwrap_or_default()
   68     68   
    }
   69     69   
}
   70     70   
static INSTANCEPROFILE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   71     71   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#InstanceProfile", "com.amazonaws.iam", "InstanceProfile");
   72     72   
static INSTANCEPROFILE_MEMBER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#InstanceProfile$Path", "com.amazonaws.iam", "InstanceProfile"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "path",
          75  +
    "Path",
   76     76   
    0,
   77     77   
);
   78     78   
static INSTANCEPROFILE_MEMBER_INSTANCE_PROFILE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.iam#InstanceProfile$InstanceProfileName",
   81     81   
        "com.amazonaws.iam",
   82     82   
        "InstanceProfile",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "instance_profile_name",
          85  +
    "InstanceProfileName",
   86     86   
    1,
   87     87   
);
   88     88   
static INSTANCEPROFILE_MEMBER_INSTANCE_PROFILE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.iam#InstanceProfile$InstanceProfileId",
   91     91   
        "com.amazonaws.iam",
   92     92   
        "InstanceProfile",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "instance_profile_id",
          95  +
    "InstanceProfileId",
   96     96   
    2,
   97     97   
);
   98     98   
static INSTANCEPROFILE_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#InstanceProfile$Arn", "com.amazonaws.iam", "InstanceProfile"),
  100    100   
    ::aws_smithy_schema::ShapeType::String,
  101         -
    "arn",
         101  +
    "Arn",
  102    102   
    3,
  103    103   
);
  104    104   
static INSTANCEPROFILE_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#InstanceProfile$CreateDate", "com.amazonaws.iam", "InstanceProfile"),
  106    106   
    ::aws_smithy_schema::ShapeType::Timestamp,
  107         -
    "create_date",
         107  +
    "CreateDate",
  108    108   
    4,
  109    109   
);
  110    110   
static INSTANCEPROFILE_MEMBER_ROLES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#InstanceProfile$Roles", "com.amazonaws.iam", "InstanceProfile"),
  112    112   
    ::aws_smithy_schema::ShapeType::List,
  113         -
    "roles",
         113  +
    "Roles",
  114    114   
    5,
  115    115   
);
  116    116   
static INSTANCEPROFILE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#InstanceProfile$Tags", "com.amazonaws.iam", "InstanceProfile"),
  118    118   
    ::aws_smithy_schema::ShapeType::List,
  119         -
    "tags",
         119  +
    "Tags",
  120    120   
    6,
  121    121   
);
  122    122   
static INSTANCEPROFILE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  123    123   
    INSTANCEPROFILE_SCHEMA_ID,
  124    124   
    ::aws_smithy_schema::ShapeType::Structure,
  125    125   
    &[
  126    126   
        &INSTANCEPROFILE_MEMBER_PATH,
  127    127   
        &INSTANCEPROFILE_MEMBER_INSTANCE_PROFILE_NAME,
  128    128   
        &INSTANCEPROFILE_MEMBER_INSTANCE_PROFILE_ID,
  129    129   
        &INSTANCEPROFILE_MEMBER_ARN,
@@ -164,164 +287,298 @@
  184    184   
                    }
  185    185   
                    Ok(())
  186    186   
                },
  187    187   
            )?;
  188    188   
        }
  189    189   
        Ok(())
  190    190   
    }
  191    191   
}
  192    192   
impl InstanceProfile {
  193    193   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  194         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  195         -
        deserializer: &mut D,
         194  +
    pub fn deserialize(
         195  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  196    196   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  197    197   
        #[allow(unused_variables, unused_mut)]
  198    198   
        let mut builder = Self::builder();
  199    199   
        #[allow(
  200    200   
            unused_variables,
  201    201   
            unreachable_code,
  202    202   
            clippy::single_match,
  203    203   
            clippy::match_single_binding,
  204    204   
            clippy::diverging_sub_expression
  205    205   
        )]
  206         -
        deserializer.read_struct(&INSTANCEPROFILE_SCHEMA, (), |_, member, deser| {
         206  +
        deserializer.read_struct(&INSTANCEPROFILE_SCHEMA, &mut |member, deser| {
  207    207   
            match member.member_index() {
  208    208   
                Some(0) => {
  209    209   
                    builder.path = Some(deser.read_string(member)?);
  210    210   
                }
  211    211   
                Some(1) => {
  212    212   
                    builder.instance_profile_name = Some(deser.read_string(member)?);
  213    213   
                }
  214    214   
                Some(2) => {
  215    215   
                    builder.instance_profile_id = Some(deser.read_string(member)?);
  216    216   
                }
  217    217   
                Some(3) => {
  218    218   
                    builder.arn = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                Some(4) => {
  221    221   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  222    222   
                }
  223    223   
                Some(5) => {
  224    224   
                    builder.roles = Some({
  225         -
                        let container = if let Some(cap) = deser.container_size() {
  226         -
                            Vec::with_capacity(cap)
  227         -
                        } else {
  228         -
                            Vec::new()
  229         -
                        };
  230         -
                        deser.read_list(member, container, |mut list, deser| {
  231         -
                            list.push(crate::types::Role::deserialize(deser)?);
  232         -
                            Ok(list)
  233         -
                        })?
         225  +
                        let mut container = Vec::new();
         226  +
                        deser.read_list(member, &mut |deser| {
         227  +
                            container.push(crate::types::Role::deserialize(deser)?);
         228  +
                            Ok(())
         229  +
                        })?;
         230  +
                        container
  234    231   
                    });
  235    232   
                }
  236    233   
                Some(6) => {
  237    234   
                    builder.tags = Some({
  238         -
                        let container = if let Some(cap) = deser.container_size() {
  239         -
                            Vec::with_capacity(cap)
  240         -
                        } else {
  241         -
                            Vec::new()
  242         -
                        };
  243         -
                        deser.read_list(member, container, |mut list, deser| {
  244         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  245         -
                            Ok(list)
  246         -
                        })?
         235  +
                        let mut container = Vec::new();
         236  +
                        deser.read_list(member, &mut |deser| {
         237  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         238  +
                            Ok(())
         239  +
                        })?;
         240  +
                        container
  247    241   
                    });
  248    242   
                }
  249    243   
                _ => {}
  250    244   
            }
  251    245   
            Ok(())
  252    246   
        })?;
         247  +
        builder.path = builder.path.or(Some(String::new()));
         248  +
        builder.instance_profile_name = builder.instance_profile_name.or(Some(String::new()));
         249  +
        builder.instance_profile_id = builder.instance_profile_id.or(Some(String::new()));
         250  +
        builder.arn = builder.arn.or(Some(String::new()));
         251  +
        builder.create_date = builder.create_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
         252  +
        builder.roles = builder.roles.or(Some(Vec::new()));
  253    253   
        builder
  254    254   
            .build()
  255    255   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  256    256   
    }
  257    257   
}
         258  +
impl InstanceProfile {
         259  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         260  +
    pub fn deserialize_with_response(
         261  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         262  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         263  +
        _status: u16,
         264  +
        _body: &[u8],
         265  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         266  +
        Self::deserialize(deserializer)
         267  +
    }
         268  +
}
  258    269   
impl InstanceProfile {
  259    270   
    /// Creates a new builder-style object to manufacture [`InstanceProfile`](crate::types::InstanceProfile).
  260    271   
    pub fn builder() -> crate::types::builders::InstanceProfileBuilder {
  261    272   
        crate::types::builders::InstanceProfileBuilder::default()
  262    273   
    }
  263    274   
}
  264    275   
  265    276   
/// A builder for [`InstanceProfile`](crate::types::InstanceProfile).
  266    277   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  267    278   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_list_policies_granting_service_access_entry.rs

@@ -9,9 +155,163 @@
   29     29   
    "com.amazonaws.iam",
   30     30   
    "ListPoliciesGrantingServiceAccessEntry",
   31     31   
);
   32     32   
static LISTPOLICIESGRANTINGSERVICEACCESSENTRY_MEMBER_SERVICE_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.iam#ListPoliciesGrantingServiceAccessEntry$ServiceNamespace",
   35     35   
        "com.amazonaws.iam",
   36     36   
        "ListPoliciesGrantingServiceAccessEntry",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "service_namespace",
          39  +
    "ServiceNamespace",
   40     40   
    0,
   41     41   
);
   42     42   
static LISTPOLICIESGRANTINGSERVICEACCESSENTRY_MEMBER_POLICIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.iam#ListPoliciesGrantingServiceAccessEntry$Policies",
   45     45   
        "com.amazonaws.iam",
   46     46   
        "ListPoliciesGrantingServiceAccessEntry",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::List,
   49         -
    "policies",
          49  +
    "Policies",
   50     50   
    1,
   51     51   
);
   52     52   
static LISTPOLICIESGRANTINGSERVICEACCESSENTRY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   53     53   
    LISTPOLICIESGRANTINGSERVICEACCESSENTRY_SCHEMA_ID,
   54     54   
    ::aws_smithy_schema::ShapeType::Structure,
   55     55   
    &[
   56     56   
        &LISTPOLICIESGRANTINGSERVICEACCESSENTRY_MEMBER_SERVICE_NAMESPACE,
   57     57   
        &LISTPOLICIESGRANTINGSERVICEACCESSENTRY_MEMBER_POLICIES,
   58     58   
    ],
   59     59   
);
   60     60   
impl ListPoliciesGrantingServiceAccessEntry {
   61     61   
    /// The schema for this shape.
   62     62   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTPOLICIESGRANTINGSERVICEACCESSENTRY_SCHEMA;
   63     63   
}
   64     64   
impl ::aws_smithy_schema::serde::SerializableStruct for ListPoliciesGrantingServiceAccessEntry {
   65     65   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   66     66   
    fn serialize_members(
   67     67   
        &self,
   68     68   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   69     69   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   70     70   
        if let Some(ref val) = self.service_namespace {
   71     71   
            ser.write_string(&LISTPOLICIESGRANTINGSERVICEACCESSENTRY_MEMBER_SERVICE_NAMESPACE, val)?;
   72     72   
        }
   73     73   
        if let Some(ref val) = self.policies {
   74     74   
            ser.write_list(
   75     75   
                &LISTPOLICIESGRANTINGSERVICEACCESSENTRY_MEMBER_POLICIES,
   76     76   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   77     77   
                    for item in val {
   78     78   
                        ser.write_struct(crate::types::PolicyGrantingServiceAccess::SCHEMA, item)?;
   79     79   
                    }
   80     80   
                    Ok(())
   81     81   
                },
   82     82   
            )?;
   83     83   
        }
   84     84   
        Ok(())
   85     85   
    }
   86     86   
}
   87     87   
impl ListPoliciesGrantingServiceAccessEntry {
   88     88   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   89         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   90         -
        deserializer: &mut D,
          89  +
    pub fn deserialize(
          90  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   91     91   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   92     92   
        #[allow(unused_variables, unused_mut)]
   93     93   
        let mut builder = Self::builder();
   94     94   
        #[allow(
   95     95   
            unused_variables,
   96     96   
            unreachable_code,
   97     97   
            clippy::single_match,
   98     98   
            clippy::match_single_binding,
   99     99   
            clippy::diverging_sub_expression
  100    100   
        )]
  101         -
        deserializer.read_struct(&LISTPOLICIESGRANTINGSERVICEACCESSENTRY_SCHEMA, (), |_, member, deser| {
         101  +
        deserializer.read_struct(&LISTPOLICIESGRANTINGSERVICEACCESSENTRY_SCHEMA, &mut |member, deser| {
  102    102   
            match member.member_index() {
  103    103   
                Some(0) => {
  104    104   
                    builder.service_namespace = Some(deser.read_string(member)?);
  105    105   
                }
  106    106   
                Some(1) => {
  107    107   
                    builder.policies = Some({
  108         -
                        let container = if let Some(cap) = deser.container_size() {
  109         -
                            Vec::with_capacity(cap)
  110         -
                        } else {
  111         -
                            Vec::new()
  112         -
                        };
  113         -
                        deser.read_list(member, container, |mut list, deser| {
  114         -
                            list.push(crate::types::PolicyGrantingServiceAccess::deserialize(deser)?);
  115         -
                            Ok(list)
  116         -
                        })?
         108  +
                        let mut container = Vec::new();
         109  +
                        deser.read_list(member, &mut |deser| {
         110  +
                            container.push(crate::types::PolicyGrantingServiceAccess::deserialize(deser)?);
         111  +
                            Ok(())
         112  +
                        })?;
         113  +
                        container
  117    114   
                    });
  118    115   
                }
  119    116   
                _ => {}
  120    117   
            }
  121    118   
            Ok(())
  122    119   
        })?;
  123    120   
        Ok(builder.build())
  124    121   
    }
  125    122   
}
         123  +
impl ListPoliciesGrantingServiceAccessEntry {
         124  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         125  +
    pub fn deserialize_with_response(
         126  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         127  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         128  +
        _status: u16,
         129  +
        _body: &[u8],
         130  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         131  +
        Self::deserialize(deserializer)
         132  +
    }
         133  +
}
  126    134   
impl ListPoliciesGrantingServiceAccessEntry {
  127    135   
    /// Creates a new builder-style object to manufacture [`ListPoliciesGrantingServiceAccessEntry`](crate::types::ListPoliciesGrantingServiceAccessEntry).
  128    136   
    pub fn builder() -> crate::types::builders::ListPoliciesGrantingServiceAccessEntryBuilder {
  129    137   
        crate::types::builders::ListPoliciesGrantingServiceAccessEntryBuilder::default()
  130    138   
    }
  131    139   
}
  132    140   
  133    141   
/// A builder for [`ListPoliciesGrantingServiceAccessEntry`](crate::types::ListPoliciesGrantingServiceAccessEntry).
  134    142   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  135    143   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_login_profile.rs

@@ -5,5 +151,164 @@
   25     25   
    /// <p>Specifies whether the user is required to set a new password on next sign-in.</p>
   26     26   
    pub fn password_reset_required(&self) -> bool {
   27     27   
        self.password_reset_required
   28     28   
    }
   29     29   
}
   30     30   
static LOGINPROFILE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#LoginProfile", "com.amazonaws.iam", "LoginProfile");
   32     32   
static LOGINPROFILE_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#LoginProfile$UserName", "com.amazonaws.iam", "LoginProfile"),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "user_name",
          35  +
    "UserName",
   36     36   
    0,
   37     37   
);
   38     38   
static LOGINPROFILE_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#LoginProfile$CreateDate", "com.amazonaws.iam", "LoginProfile"),
   40     40   
    ::aws_smithy_schema::ShapeType::Timestamp,
   41         -
    "create_date",
          41  +
    "CreateDate",
   42     42   
    1,
   43     43   
);
   44     44   
static LOGINPROFILE_MEMBER_PASSWORD_RESET_REQUIRED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.iam#LoginProfile$PasswordResetRequired",
   47     47   
        "com.amazonaws.iam",
   48     48   
        "LoginProfile",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::Boolean,
   51         -
    "password_reset_required",
          51  +
    "PasswordResetRequired",
   52     52   
    2,
   53     53   
);
   54     54   
static LOGINPROFILE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   55     55   
    LOGINPROFILE_SCHEMA_ID,
   56     56   
    ::aws_smithy_schema::ShapeType::Structure,
   57     57   
    &[
   58     58   
        &LOGINPROFILE_MEMBER_USER_NAME,
   59     59   
        &LOGINPROFILE_MEMBER_CREATE_DATE,
   60     60   
        &LOGINPROFILE_MEMBER_PASSWORD_RESET_REQUIRED,
   61     61   
    ],
   62     62   
);
   63     63   
impl LoginProfile {
   64     64   
    /// The schema for this shape.
   65     65   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LOGINPROFILE_SCHEMA;
   66     66   
}
   67     67   
impl ::aws_smithy_schema::serde::SerializableStruct for LoginProfile {
   68     68   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   69     69   
    fn serialize_members(
   70     70   
        &self,
   71     71   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   72     72   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   73     73   
        {
   74     74   
            let val = &self.user_name;
   75     75   
            ser.write_string(&LOGINPROFILE_MEMBER_USER_NAME, val)?;
   76     76   
        }
   77     77   
        {
   78     78   
            let val = &self.create_date;
   79     79   
            ser.write_timestamp(&LOGINPROFILE_MEMBER_CREATE_DATE, val)?;
   80     80   
        }
   81     81   
        {
   82     82   
            let val = &self.password_reset_required;
   83     83   
            ser.write_boolean(&LOGINPROFILE_MEMBER_PASSWORD_RESET_REQUIRED, *val)?;
   84     84   
        }
   85     85   
        Ok(())
   86     86   
    }
   87     87   
}
   88     88   
impl LoginProfile {
   89     89   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   90         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   91         -
        deserializer: &mut D,
          90  +
    pub fn deserialize(
          91  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   92     92   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   93     93   
        #[allow(unused_variables, unused_mut)]
   94     94   
        let mut builder = Self::builder();
   95     95   
        #[allow(
   96     96   
            unused_variables,
   97     97   
            unreachable_code,
   98     98   
            clippy::single_match,
   99     99   
            clippy::match_single_binding,
  100    100   
            clippy::diverging_sub_expression
  101    101   
        )]
  102         -
        deserializer.read_struct(&LOGINPROFILE_SCHEMA, (), |_, member, deser| {
         102  +
        deserializer.read_struct(&LOGINPROFILE_SCHEMA, &mut |member, deser| {
  103    103   
            match member.member_index() {
  104    104   
                Some(0) => {
  105    105   
                    builder.user_name = Some(deser.read_string(member)?);
  106    106   
                }
  107    107   
                Some(1) => {
  108    108   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  109    109   
                }
  110    110   
                Some(2) => {
  111    111   
                    builder.password_reset_required = Some(deser.read_boolean(member)?);
  112    112   
                }
  113    113   
                _ => {}
  114    114   
            }
  115    115   
            Ok(())
  116    116   
        })?;
         117  +
        builder.user_name = builder.user_name.or(Some(String::new()));
         118  +
        builder.create_date = builder.create_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  117    119   
        builder
  118    120   
            .build()
  119    121   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  120    122   
    }
  121    123   
}
         124  +
impl LoginProfile {
         125  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         126  +
    pub fn deserialize_with_response(
         127  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         128  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         129  +
        _status: u16,
         130  +
        _body: &[u8],
         131  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         132  +
        Self::deserialize(deserializer)
         133  +
    }
         134  +
}
  122    135   
impl LoginProfile {
  123    136   
    /// Creates a new builder-style object to manufacture [`LoginProfile`](crate::types::LoginProfile).
  124    137   
    pub fn builder() -> crate::types::builders::LoginProfileBuilder {
  125    138   
        crate::types::builders::LoginProfileBuilder::default()
  126    139   
    }
  127    140   
}
  128    141   
  129    142   
/// A builder for [`LoginProfile`](crate::types::LoginProfile).
  130    143   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  131    144   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_managed_policy_detail.rs

@@ -77,77 +239,239 @@
   97     97   
}
   98     98   
static MANAGEDPOLICYDETAIL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#ManagedPolicyDetail", "com.amazonaws.iam", "ManagedPolicyDetail");
  100    100   
static MANAGEDPOLICYDETAIL_MEMBER_POLICY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.iam#ManagedPolicyDetail$PolicyName",
  103    103   
        "com.amazonaws.iam",
  104    104   
        "ManagedPolicyDetail",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "policy_name",
         107  +
    "PolicyName",
  108    108   
    0,
  109    109   
);
  110    110   
static MANAGEDPOLICYDETAIL_MEMBER_POLICY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.iam#ManagedPolicyDetail$PolicyId",
  113    113   
        "com.amazonaws.iam",
  114    114   
        "ManagedPolicyDetail",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::String,
  117         -
    "policy_id",
         117  +
    "PolicyId",
  118    118   
    1,
  119    119   
);
  120    120   
static MANAGEDPOLICYDETAIL_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#ManagedPolicyDetail$Arn", "com.amazonaws.iam", "ManagedPolicyDetail"),
  122    122   
    ::aws_smithy_schema::ShapeType::String,
  123         -
    "arn",
         123  +
    "Arn",
  124    124   
    2,
  125    125   
);
  126    126   
static MANAGEDPOLICYDETAIL_MEMBER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#ManagedPolicyDetail$Path", "com.amazonaws.iam", "ManagedPolicyDetail"),
  128    128   
    ::aws_smithy_schema::ShapeType::String,
  129         -
    "path",
         129  +
    "Path",
  130    130   
    3,
  131    131   
);
  132    132   
static MANAGEDPOLICYDETAIL_MEMBER_DEFAULT_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static(
  134    134   
        "com.amazonaws.iam#ManagedPolicyDetail$DefaultVersionId",
  135    135   
        "com.amazonaws.iam",
  136    136   
        "ManagedPolicyDetail",
  137    137   
    ),
  138    138   
    ::aws_smithy_schema::ShapeType::String,
  139         -
    "default_version_id",
         139  +
    "DefaultVersionId",
  140    140   
    4,
  141    141   
);
  142    142   
static MANAGEDPOLICYDETAIL_MEMBER_ATTACHMENT_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  143    143   
    ::aws_smithy_schema::ShapeId::from_static(
  144    144   
        "com.amazonaws.iam#ManagedPolicyDetail$AttachmentCount",
  145    145   
        "com.amazonaws.iam",
  146    146   
        "ManagedPolicyDetail",
  147    147   
    ),
  148    148   
    ::aws_smithy_schema::ShapeType::Integer,
  149         -
    "attachment_count",
         149  +
    "AttachmentCount",
  150    150   
    5,
  151    151   
);
  152    152   
static MANAGEDPOLICYDETAIL_MEMBER_PERMISSIONS_BOUNDARY_USAGE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  153    153   
    ::aws_smithy_schema::ShapeId::from_static(
  154    154   
        "com.amazonaws.iam#ManagedPolicyDetail$PermissionsBoundaryUsageCount",
  155    155   
        "com.amazonaws.iam",
  156    156   
        "ManagedPolicyDetail",
  157    157   
    ),
  158    158   
    ::aws_smithy_schema::ShapeType::Integer,
  159         -
    "permissions_boundary_usage_count",
         159  +
    "PermissionsBoundaryUsageCount",
  160    160   
    6,
  161    161   
);
  162    162   
static MANAGEDPOLICYDETAIL_MEMBER_IS_ATTACHABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  163    163   
    ::aws_smithy_schema::ShapeId::from_static(
  164    164   
        "com.amazonaws.iam#ManagedPolicyDetail$IsAttachable",
  165    165   
        "com.amazonaws.iam",
  166    166   
        "ManagedPolicyDetail",
  167    167   
    ),
  168    168   
    ::aws_smithy_schema::ShapeType::Boolean,
  169         -
    "is_attachable",
         169  +
    "IsAttachable",
  170    170   
    7,
  171    171   
);
  172    172   
static MANAGEDPOLICYDETAIL_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  173    173   
    ::aws_smithy_schema::ShapeId::from_static(
  174    174   
        "com.amazonaws.iam#ManagedPolicyDetail$Description",
  175    175   
        "com.amazonaws.iam",
  176    176   
        "ManagedPolicyDetail",
  177    177   
    ),
  178    178   
    ::aws_smithy_schema::ShapeType::String,
  179         -
    "description",
         179  +
    "Description",
  180    180   
    8,
  181    181   
);
  182    182   
static MANAGEDPOLICYDETAIL_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  183    183   
    ::aws_smithy_schema::ShapeId::from_static(
  184    184   
        "com.amazonaws.iam#ManagedPolicyDetail$CreateDate",
  185    185   
        "com.amazonaws.iam",
  186    186   
        "ManagedPolicyDetail",
  187    187   
    ),
  188    188   
    ::aws_smithy_schema::ShapeType::Timestamp,
  189         -
    "create_date",
         189  +
    "CreateDate",
  190    190   
    9,
  191    191   
);
  192    192   
static MANAGEDPOLICYDETAIL_MEMBER_UPDATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  193    193   
    ::aws_smithy_schema::ShapeId::from_static(
  194    194   
        "com.amazonaws.iam#ManagedPolicyDetail$UpdateDate",
  195    195   
        "com.amazonaws.iam",
  196    196   
        "ManagedPolicyDetail",
  197    197   
    ),
  198    198   
    ::aws_smithy_schema::ShapeType::Timestamp,
  199         -
    "update_date",
         199  +
    "UpdateDate",
  200    200   
    10,
  201    201   
);
  202    202   
static MANAGEDPOLICYDETAIL_MEMBER_POLICY_VERSION_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  203    203   
    ::aws_smithy_schema::ShapeId::from_static(
  204    204   
        "com.amazonaws.iam#ManagedPolicyDetail$PolicyVersionList",
  205    205   
        "com.amazonaws.iam",
  206    206   
        "ManagedPolicyDetail",
  207    207   
    ),
  208    208   
    ::aws_smithy_schema::ShapeType::List,
  209         -
    "policy_version_list",
         209  +
    "PolicyVersionList",
  210    210   
    11,
  211    211   
);
  212    212   
static MANAGEDPOLICYDETAIL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  213    213   
    MANAGEDPOLICYDETAIL_SCHEMA_ID,
  214    214   
    ::aws_smithy_schema::ShapeType::Structure,
  215    215   
    &[
  216    216   
        &MANAGEDPOLICYDETAIL_MEMBER_POLICY_NAME,
  217    217   
        &MANAGEDPOLICYDETAIL_MEMBER_POLICY_ID,
  218    218   
        &MANAGEDPOLICYDETAIL_MEMBER_ARN,
  219    219   
        &MANAGEDPOLICYDETAIL_MEMBER_PATH,
@@ -260,260 +386,394 @@
  280    280   
                    }
  281    281   
                    Ok(())
  282    282   
                },
  283    283   
            )?;
  284    284   
        }
  285    285   
        Ok(())
  286    286   
    }
  287    287   
}
  288    288   
impl ManagedPolicyDetail {
  289    289   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  290         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  291         -
        deserializer: &mut D,
         290  +
    pub fn deserialize(
         291  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  292    292   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  293    293   
        #[allow(unused_variables, unused_mut)]
  294    294   
        let mut builder = Self::builder();
  295    295   
        #[allow(
  296    296   
            unused_variables,
  297    297   
            unreachable_code,
  298    298   
            clippy::single_match,
  299    299   
            clippy::match_single_binding,
  300    300   
            clippy::diverging_sub_expression
  301    301   
        )]
  302         -
        deserializer.read_struct(&MANAGEDPOLICYDETAIL_SCHEMA, (), |_, member, deser| {
         302  +
        deserializer.read_struct(&MANAGEDPOLICYDETAIL_SCHEMA, &mut |member, deser| {
  303    303   
            match member.member_index() {
  304    304   
                Some(0) => {
  305    305   
                    builder.policy_name = Some(deser.read_string(member)?);
  306    306   
                }
  307    307   
                Some(1) => {
  308    308   
                    builder.policy_id = Some(deser.read_string(member)?);
  309    309   
                }
  310    310   
                Some(2) => {
  311    311   
                    builder.arn = Some(deser.read_string(member)?);
  312    312   
                }
  313    313   
                Some(3) => {
  314    314   
                    builder.path = Some(deser.read_string(member)?);
  315    315   
                }
  316    316   
                Some(4) => {
  317    317   
                    builder.default_version_id = Some(deser.read_string(member)?);
  318    318   
                }
  319    319   
                Some(5) => {
  320    320   
                    builder.attachment_count = Some(deser.read_integer(member)?);
  321    321   
                }
  322    322   
                Some(6) => {
  323    323   
                    builder.permissions_boundary_usage_count = Some(deser.read_integer(member)?);
  324    324   
                }
  325    325   
                Some(7) => {
  326    326   
                    builder.is_attachable = Some(deser.read_boolean(member)?);
  327    327   
                }
  328    328   
                Some(8) => {
  329    329   
                    builder.description = Some(deser.read_string(member)?);
  330    330   
                }
  331    331   
                Some(9) => {
  332    332   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  333    333   
                }
  334    334   
                Some(10) => {
  335    335   
                    builder.update_date = Some(deser.read_timestamp(member)?);
  336    336   
                }
  337    337   
                Some(11) => {
  338    338   
                    builder.policy_version_list = Some({
  339         -
                        let container = if let Some(cap) = deser.container_size() {
  340         -
                            Vec::with_capacity(cap)
  341         -
                        } else {
  342         -
                            Vec::new()
  343         -
                        };
  344         -
                        deser.read_list(member, container, |mut list, deser| {
  345         -
                            list.push(crate::types::PolicyVersion::deserialize(deser)?);
  346         -
                            Ok(list)
  347         -
                        })?
         339  +
                        let mut container = Vec::new();
         340  +
                        deser.read_list(member, &mut |deser| {
         341  +
                            container.push(crate::types::PolicyVersion::deserialize(deser)?);
         342  +
                            Ok(())
         343  +
                        })?;
         344  +
                        container
  348    345   
                    });
  349    346   
                }
  350    347   
                _ => {}
  351    348   
            }
  352    349   
            Ok(())
  353    350   
        })?;
  354    351   
        Ok(builder.build())
  355    352   
    }
  356    353   
}
         354  +
impl ManagedPolicyDetail {
         355  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         356  +
    pub fn deserialize_with_response(
         357  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         358  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         359  +
        _status: u16,
         360  +
        _body: &[u8],
         361  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         362  +
        Self::deserialize(deserializer)
         363  +
    }
         364  +
}
  357    365   
impl ManagedPolicyDetail {
  358    366   
    /// Creates a new builder-style object to manufacture [`ManagedPolicyDetail`](crate::types::ManagedPolicyDetail).
  359    367   
    pub fn builder() -> crate::types::builders::ManagedPolicyDetailBuilder {
  360    368   
        crate::types::builders::ManagedPolicyDetailBuilder::default()
  361    369   
    }
  362    370   
}
  363    371   
  364    372   
/// A builder for [`ManagedPolicyDetail`](crate::types::ManagedPolicyDetail).
  365    373   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  366    374   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_mfa_device.rs

@@ -6,6 +148,162 @@
   26     26   
    /// <p>The date when the MFA device was enabled for the user.</p>
   27     27   
    pub fn enable_date(&self) -> &::aws_smithy_types::DateTime {
   28     28   
        &self.enable_date
   29     29   
    }
   30     30   
}
   31     31   
static MFADEVICE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#MFADevice", "com.amazonaws.iam", "MFADevice");
   33     33   
static MFADEVICE_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#MFADevice$UserName", "com.amazonaws.iam", "MFADevice"),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "user_name",
          36  +
    "UserName",
   37     37   
    0,
   38     38   
);
   39     39   
static MFADEVICE_MEMBER_SERIAL_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#MFADevice$SerialNumber", "com.amazonaws.iam", "MFADevice"),
   41     41   
    ::aws_smithy_schema::ShapeType::String,
   42         -
    "serial_number",
          42  +
    "SerialNumber",
   43     43   
    1,
   44     44   
);
   45     45   
static MFADEVICE_MEMBER_ENABLE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#MFADevice$EnableDate", "com.amazonaws.iam", "MFADevice"),
   47     47   
    ::aws_smithy_schema::ShapeType::Timestamp,
   48         -
    "enable_date",
          48  +
    "EnableDate",
   49     49   
    2,
   50     50   
);
   51     51   
static MFADEVICE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   52     52   
    MFADEVICE_SCHEMA_ID,
   53     53   
    ::aws_smithy_schema::ShapeType::Structure,
   54     54   
    &[
   55     55   
        &MFADEVICE_MEMBER_USER_NAME,
   56     56   
        &MFADEVICE_MEMBER_SERIAL_NUMBER,
   57     57   
        &MFADEVICE_MEMBER_ENABLE_DATE,
   58     58   
    ],
   59     59   
);
   60     60   
impl MfaDevice {
   61     61   
    /// The schema for this shape.
   62     62   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MFADEVICE_SCHEMA;
   63     63   
}
   64     64   
impl ::aws_smithy_schema::serde::SerializableStruct for MfaDevice {
   65     65   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   66     66   
    fn serialize_members(
   67     67   
        &self,
   68     68   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   69     69   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   70     70   
        {
   71     71   
            let val = &self.user_name;
   72     72   
            ser.write_string(&MFADEVICE_MEMBER_USER_NAME, val)?;
   73     73   
        }
   74     74   
        {
   75     75   
            let val = &self.serial_number;
   76     76   
            ser.write_string(&MFADEVICE_MEMBER_SERIAL_NUMBER, val)?;
   77     77   
        }
   78     78   
        {
   79     79   
            let val = &self.enable_date;
   80     80   
            ser.write_timestamp(&MFADEVICE_MEMBER_ENABLE_DATE, val)?;
   81     81   
        }
   82     82   
        Ok(())
   83     83   
    }
   84     84   
}
   85     85   
impl MfaDevice {
   86     86   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   87         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   88         -
        deserializer: &mut D,
          87  +
    pub fn deserialize(
          88  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   89     89   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   90     90   
        #[allow(unused_variables, unused_mut)]
   91     91   
        let mut builder = Self::builder();
   92     92   
        #[allow(
   93     93   
            unused_variables,
   94     94   
            unreachable_code,
   95     95   
            clippy::single_match,
   96     96   
            clippy::match_single_binding,
   97     97   
            clippy::diverging_sub_expression
   98     98   
        )]
   99         -
        deserializer.read_struct(&MFADEVICE_SCHEMA, (), |_, member, deser| {
          99  +
        deserializer.read_struct(&MFADEVICE_SCHEMA, &mut |member, deser| {
  100    100   
            match member.member_index() {
  101    101   
                Some(0) => {
  102    102   
                    builder.user_name = Some(deser.read_string(member)?);
  103    103   
                }
  104    104   
                Some(1) => {
  105    105   
                    builder.serial_number = Some(deser.read_string(member)?);
  106    106   
                }
  107    107   
                Some(2) => {
  108    108   
                    builder.enable_date = Some(deser.read_timestamp(member)?);
  109    109   
                }
  110    110   
                _ => {}
  111    111   
            }
  112    112   
            Ok(())
  113    113   
        })?;
         114  +
        builder.user_name = builder.user_name.or(Some(String::new()));
         115  +
        builder.serial_number = builder.serial_number.or(Some(String::new()));
         116  +
        builder.enable_date = builder.enable_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  114    117   
        builder
  115    118   
            .build()
  116    119   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  117    120   
    }
  118    121   
}
         122  +
impl MfaDevice {
         123  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         124  +
    pub fn deserialize_with_response(
         125  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         126  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         127  +
        _status: u16,
         128  +
        _body: &[u8],
         129  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         130  +
        Self::deserialize(deserializer)
         131  +
    }
         132  +
}
  119    133   
impl MfaDevice {
  120    134   
    /// Creates a new builder-style object to manufacture [`MfaDevice`](crate::types::MfaDevice).
  121    135   
    pub fn builder() -> crate::types::builders::MfaDeviceBuilder {
  122    136   
        crate::types::builders::MfaDeviceBuilder::default()
  123    137   
    }
  124    138   
}
  125    139   
  126    140   
/// A builder for [`MfaDevice`](crate::types::MfaDevice).
  127    141   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  128    142   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_open_id_connect_provider_list_entry.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_organizations_decision_detail.rs

@@ -1,1 +108,119 @@
   18     18   
    "com.amazonaws.iam",
   19     19   
    "OrganizationsDecisionDetail",
   20     20   
);
   21     21   
static ORGANIZATIONSDECISIONDETAIL_MEMBER_ALLOWED_BY_ORGANIZATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.iam#OrganizationsDecisionDetail$AllowedByOrganizations",
   24     24   
        "com.amazonaws.iam",
   25     25   
        "OrganizationsDecisionDetail",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Boolean,
   28         -
    "allowed_by_organizations",
          28  +
    "AllowedByOrganizations",
   29     29   
    0,
   30     30   
);
   31     31   
static ORGANIZATIONSDECISIONDETAIL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    ORGANIZATIONSDECISIONDETAIL_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&ORGANIZATIONSDECISIONDETAIL_MEMBER_ALLOWED_BY_ORGANIZATIONS],
   35     35   
);
   36     36   
impl OrganizationsDecisionDetail {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ORGANIZATIONSDECISIONDETAIL_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for OrganizationsDecisionDetail {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        {
   47     47   
            let val = &self.allowed_by_organizations;
   48     48   
            ser.write_boolean(&ORGANIZATIONSDECISIONDETAIL_MEMBER_ALLOWED_BY_ORGANIZATIONS, *val)?;
   49     49   
        }
   50     50   
        Ok(())
   51     51   
    }
   52     52   
}
   53     53   
impl OrganizationsDecisionDetail {
   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(&ORGANIZATIONSDECISIONDETAIL_SCHEMA, (), |_, member, deser| {
          67  +
        deserializer.read_struct(&ORGANIZATIONSDECISIONDETAIL_SCHEMA, &mut |member, deser| {
   68     68   
            match member.member_index() {
   69     69   
                Some(0) => {
   70     70   
                    builder.allowed_by_organizations = Some(deser.read_boolean(member)?);
   71     71   
                }
   72     72   
                _ => {}
   73     73   
            }
   74     74   
            Ok(())
   75     75   
        })?;
   76     76   
        Ok(builder.build())
   77     77   
    }
   78     78   
}
          79  +
impl OrganizationsDecisionDetail {
          80  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          81  +
    pub fn deserialize_with_response(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          84  +
        _status: u16,
          85  +
        _body: &[u8],
          86  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          87  +
        Self::deserialize(deserializer)
          88  +
    }
          89  +
}
   79     90   
impl OrganizationsDecisionDetail {
   80     91   
    /// Creates a new builder-style object to manufacture [`OrganizationsDecisionDetail`](crate::types::OrganizationsDecisionDetail).
   81     92   
    pub fn builder() -> crate::types::builders::OrganizationsDecisionDetailBuilder {
   82     93   
        crate::types::builders::OrganizationsDecisionDetailBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`OrganizationsDecisionDetail`](crate::types::OrganizationsDecisionDetail).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_password_policy.rs

@@ -52,52 +182,182 @@
   72     72   
}
   73     73   
static PASSWORDPOLICY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   74     74   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PasswordPolicy", "com.amazonaws.iam", "PasswordPolicy");
   75     75   
static PASSWORDPOLICY_MEMBER_MINIMUM_PASSWORD_LENGTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.iam#PasswordPolicy$MinimumPasswordLength",
   78     78   
        "com.amazonaws.iam",
   79     79   
        "PasswordPolicy",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::Integer,
   82         -
    "minimum_password_length",
          82  +
    "MinimumPasswordLength",
   83     83   
    0,
   84     84   
);
   85     85   
static PASSWORDPOLICY_MEMBER_REQUIRE_SYMBOLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PasswordPolicy$RequireSymbols", "com.amazonaws.iam", "PasswordPolicy"),
   87     87   
    ::aws_smithy_schema::ShapeType::Boolean,
   88         -
    "require_symbols",
          88  +
    "RequireSymbols",
   89     89   
    1,
   90     90   
);
   91     91   
static PASSWORDPOLICY_MEMBER_REQUIRE_NUMBERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PasswordPolicy$RequireNumbers", "com.amazonaws.iam", "PasswordPolicy"),
   93     93   
    ::aws_smithy_schema::ShapeType::Boolean,
   94         -
    "require_numbers",
          94  +
    "RequireNumbers",
   95     95   
    2,
   96     96   
);
   97     97   
static PASSWORDPOLICY_MEMBER_REQUIRE_UPPERCASE_CHARACTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.iam#PasswordPolicy$RequireUppercaseCharacters",
  100    100   
        "com.amazonaws.iam",
  101    101   
        "PasswordPolicy",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::Boolean,
  104         -
    "require_uppercase_characters",
         104  +
    "RequireUppercaseCharacters",
  105    105   
    3,
  106    106   
);
  107    107   
static PASSWORDPOLICY_MEMBER_REQUIRE_LOWERCASE_CHARACTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.iam#PasswordPolicy$RequireLowercaseCharacters",
  110    110   
        "com.amazonaws.iam",
  111    111   
        "PasswordPolicy",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::Boolean,
  114         -
    "require_lowercase_characters",
         114  +
    "RequireLowercaseCharacters",
  115    115   
    4,
  116    116   
);
  117    117   
static PASSWORDPOLICY_MEMBER_ALLOW_USERS_TO_CHANGE_PASSWORD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.iam#PasswordPolicy$AllowUsersToChangePassword",
  120    120   
        "com.amazonaws.iam",
  121    121   
        "PasswordPolicy",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::Boolean,
  124         -
    "allow_users_to_change_password",
         124  +
    "AllowUsersToChangePassword",
  125    125   
    5,
  126    126   
);
  127    127   
static PASSWORDPOLICY_MEMBER_EXPIRE_PASSWORDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PasswordPolicy$ExpirePasswords", "com.amazonaws.iam", "PasswordPolicy"),
  129    129   
    ::aws_smithy_schema::ShapeType::Boolean,
  130         -
    "expire_passwords",
         130  +
    "ExpirePasswords",
  131    131   
    6,
  132    132   
);
  133    133   
static PASSWORDPOLICY_MEMBER_MAX_PASSWORD_AGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PasswordPolicy$MaxPasswordAge", "com.amazonaws.iam", "PasswordPolicy"),
  135    135   
    ::aws_smithy_schema::ShapeType::Integer,
  136         -
    "max_password_age",
         136  +
    "MaxPasswordAge",
  137    137   
    7,
  138    138   
);
  139    139   
static PASSWORDPOLICY_MEMBER_PASSWORD_REUSE_PREVENTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.iam#PasswordPolicy$PasswordReusePrevention",
  142    142   
        "com.amazonaws.iam",
  143    143   
        "PasswordPolicy",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::Integer,
  146         -
    "password_reuse_prevention",
         146  +
    "PasswordReusePrevention",
  147    147   
    8,
  148    148   
);
  149    149   
static PASSWORDPOLICY_MEMBER_HARD_EXPIRY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PasswordPolicy$HardExpiry", "com.amazonaws.iam", "PasswordPolicy"),
  151    151   
    ::aws_smithy_schema::ShapeType::Boolean,
  152         -
    "hard_expiry",
         152  +
    "HardExpiry",
  153    153   
    9,
  154    154   
);
  155    155   
static PASSWORDPOLICY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  156    156   
    PASSWORDPOLICY_SCHEMA_ID,
  157    157   
    ::aws_smithy_schema::ShapeType::Structure,
  158    158   
    &[
  159    159   
        &PASSWORDPOLICY_MEMBER_MINIMUM_PASSWORD_LENGTH,
  160    160   
        &PASSWORDPOLICY_MEMBER_REQUIRE_SYMBOLS,
  161    161   
        &PASSWORDPOLICY_MEMBER_REQUIRE_NUMBERS,
  162    162   
        &PASSWORDPOLICY_MEMBER_REQUIRE_UPPERCASE_CHARACTERS,
@@ -192,192 +302,313 @@
  212    212   
            ser.write_integer(&PASSWORDPOLICY_MEMBER_PASSWORD_REUSE_PREVENTION, *val)?;
  213    213   
        }
  214    214   
        if let Some(ref val) = self.hard_expiry {
  215    215   
            ser.write_boolean(&PASSWORDPOLICY_MEMBER_HARD_EXPIRY, *val)?;
  216    216   
        }
  217    217   
        Ok(())
  218    218   
    }
  219    219   
}
  220    220   
impl PasswordPolicy {
  221    221   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  222         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  223         -
        deserializer: &mut D,
         222  +
    pub fn deserialize(
         223  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  224    224   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  225    225   
        #[allow(unused_variables, unused_mut)]
  226    226   
        let mut builder = Self::builder();
  227    227   
        #[allow(
  228    228   
            unused_variables,
  229    229   
            unreachable_code,
  230    230   
            clippy::single_match,
  231    231   
            clippy::match_single_binding,
  232    232   
            clippy::diverging_sub_expression
  233    233   
        )]
  234         -
        deserializer.read_struct(&PASSWORDPOLICY_SCHEMA, (), |_, member, deser| {
         234  +
        deserializer.read_struct(&PASSWORDPOLICY_SCHEMA, &mut |member, deser| {
  235    235   
            match member.member_index() {
  236    236   
                Some(0) => {
  237    237   
                    builder.minimum_password_length = Some(deser.read_integer(member)?);
  238    238   
                }
  239    239   
                Some(1) => {
  240    240   
                    builder.require_symbols = Some(deser.read_boolean(member)?);
  241    241   
                }
  242    242   
                Some(2) => {
  243    243   
                    builder.require_numbers = Some(deser.read_boolean(member)?);
  244    244   
                }
  245    245   
                Some(3) => {
  246    246   
                    builder.require_uppercase_characters = Some(deser.read_boolean(member)?);
  247    247   
                }
  248    248   
                Some(4) => {
  249    249   
                    builder.require_lowercase_characters = Some(deser.read_boolean(member)?);
  250    250   
                }
  251    251   
                Some(5) => {
  252    252   
                    builder.allow_users_to_change_password = Some(deser.read_boolean(member)?);
  253    253   
                }
  254    254   
                Some(6) => {
  255    255   
                    builder.expire_passwords = Some(deser.read_boolean(member)?);
  256    256   
                }
  257    257   
                Some(7) => {
  258    258   
                    builder.max_password_age = Some(deser.read_integer(member)?);
  259    259   
                }
  260    260   
                Some(8) => {
  261    261   
                    builder.password_reuse_prevention = Some(deser.read_integer(member)?);
  262    262   
                }
  263    263   
                Some(9) => {
  264    264   
                    builder.hard_expiry = Some(deser.read_boolean(member)?);
  265    265   
                }
  266    266   
                _ => {}
  267    267   
            }
  268    268   
            Ok(())
  269    269   
        })?;
  270    270   
        Ok(builder.build())
  271    271   
    }
  272    272   
}
         273  +
impl PasswordPolicy {
         274  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         275  +
    pub fn deserialize_with_response(
         276  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         277  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         278  +
        _status: u16,
         279  +
        _body: &[u8],
         280  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         281  +
        Self::deserialize(deserializer)
         282  +
    }
         283  +
}
  273    284   
impl PasswordPolicy {
  274    285   
    /// Creates a new builder-style object to manufacture [`PasswordPolicy`](crate::types::PasswordPolicy).
  275    286   
    pub fn builder() -> crate::types::builders::PasswordPolicyBuilder {
  276    287   
        crate::types::builders::PasswordPolicyBuilder::default()
  277    288   
    }
  278    289   
}
  279    290   
  280    291   
/// A builder for [`PasswordPolicy`](crate::types::PasswordPolicy).
  281    292   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  282    293   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_permissions_boundary_decision_detail.rs

@@ -1,1 +109,120 @@
   19     19   
    "PermissionsBoundaryDecisionDetail",
   20     20   
);
   21     21   
static PERMISSIONSBOUNDARYDECISIONDETAIL_MEMBER_ALLOWED_BY_PERMISSIONS_BOUNDARY: ::aws_smithy_schema::Schema =
   22     22   
    ::aws_smithy_schema::Schema::new_member(
   23     23   
        ::aws_smithy_schema::ShapeId::from_static(
   24     24   
            "com.amazonaws.iam#PermissionsBoundaryDecisionDetail$AllowedByPermissionsBoundary",
   25     25   
            "com.amazonaws.iam",
   26     26   
            "PermissionsBoundaryDecisionDetail",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Boolean,
   29         -
        "allowed_by_permissions_boundary",
          29  +
        "AllowedByPermissionsBoundary",
   30     30   
        0,
   31     31   
    );
   32     32   
static PERMISSIONSBOUNDARYDECISIONDETAIL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   33     33   
    PERMISSIONSBOUNDARYDECISIONDETAIL_SCHEMA_ID,
   34     34   
    ::aws_smithy_schema::ShapeType::Structure,
   35     35   
    &[&PERMISSIONSBOUNDARYDECISIONDETAIL_MEMBER_ALLOWED_BY_PERMISSIONS_BOUNDARY],
   36     36   
);
   37     37   
impl PermissionsBoundaryDecisionDetail {
   38     38   
    /// The schema for this shape.
   39     39   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PERMISSIONSBOUNDARYDECISIONDETAIL_SCHEMA;
   40     40   
}
   41     41   
impl ::aws_smithy_schema::serde::SerializableStruct for PermissionsBoundaryDecisionDetail {
   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   
        {
   48     48   
            let val = &self.allowed_by_permissions_boundary;
   49     49   
            ser.write_boolean(&PERMISSIONSBOUNDARYDECISIONDETAIL_MEMBER_ALLOWED_BY_PERMISSIONS_BOUNDARY, *val)?;
   50     50   
        }
   51     51   
        Ok(())
   52     52   
    }
   53     53   
}
   54     54   
impl PermissionsBoundaryDecisionDetail {
   55     55   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   56         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   57         -
        deserializer: &mut D,
          56  +
    pub fn deserialize(
          57  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   58     58   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   59     59   
        #[allow(unused_variables, unused_mut)]
   60     60   
        let mut builder = Self::builder();
   61     61   
        #[allow(
   62     62   
            unused_variables,
   63     63   
            unreachable_code,
   64     64   
            clippy::single_match,
   65     65   
            clippy::match_single_binding,
   66     66   
            clippy::diverging_sub_expression
   67     67   
        )]
   68         -
        deserializer.read_struct(&PERMISSIONSBOUNDARYDECISIONDETAIL_SCHEMA, (), |_, member, deser| {
          68  +
        deserializer.read_struct(&PERMISSIONSBOUNDARYDECISIONDETAIL_SCHEMA, &mut |member, deser| {
   69     69   
            match member.member_index() {
   70     70   
                Some(0) => {
   71     71   
                    builder.allowed_by_permissions_boundary = Some(deser.read_boolean(member)?);
   72     72   
                }
   73     73   
                _ => {}
   74     74   
            }
   75     75   
            Ok(())
   76     76   
        })?;
   77     77   
        Ok(builder.build())
   78     78   
    }
   79     79   
}
          80  +
impl PermissionsBoundaryDecisionDetail {
          81  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          82  +
    pub fn deserialize_with_response(
          83  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          85  +
        _status: u16,
          86  +
        _body: &[u8],
          87  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          88  +
        Self::deserialize(deserializer)
          89  +
    }
          90  +
}
   80     91   
impl PermissionsBoundaryDecisionDetail {
   81     92   
    /// Creates a new builder-style object to manufacture [`PermissionsBoundaryDecisionDetail`](crate::types::PermissionsBoundaryDecisionDetail).
   82     93   
    pub fn builder() -> crate::types::builders::PermissionsBoundaryDecisionDetailBuilder {
   83     94   
        crate::types::builders::PermissionsBoundaryDecisionDetailBuilder::default()
   84     95   
    }
   85     96   
}
   86     97   
   87     98   
/// A builder for [`PermissionsBoundaryDecisionDetail`](crate::types::PermissionsBoundaryDecisionDetail).
   88     99   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   89    100   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_policy.rs

@@ -73,73 +199,199 @@
   93     93   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   94     94   
    pub fn tags(&self) -> &[crate::types::Tag] {
   95     95   
        self.tags.as_deref().unwrap_or_default()
   96     96   
    }
   97     97   
}
   98     98   
static POLICY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy", "com.amazonaws.iam", "Policy");
  100    100   
static POLICY_MEMBER_POLICY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$PolicyName", "com.amazonaws.iam", "Policy"),
  102    102   
    ::aws_smithy_schema::ShapeType::String,
  103         -
    "policy_name",
         103  +
    "PolicyName",
  104    104   
    0,
  105    105   
);
  106    106   
static POLICY_MEMBER_POLICY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$PolicyId", "com.amazonaws.iam", "Policy"),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "policy_id",
         109  +
    "PolicyId",
  110    110   
    1,
  111    111   
);
  112    112   
static POLICY_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  113    113   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$Arn", "com.amazonaws.iam", "Policy"),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "arn",
         115  +
    "Arn",
  116    116   
    2,
  117    117   
);
  118    118   
static POLICY_MEMBER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$Path", "com.amazonaws.iam", "Policy"),
  120    120   
    ::aws_smithy_schema::ShapeType::String,
  121         -
    "path",
         121  +
    "Path",
  122    122   
    3,
  123    123   
);
  124    124   
static POLICY_MEMBER_DEFAULT_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$DefaultVersionId", "com.amazonaws.iam", "Policy"),
  126    126   
    ::aws_smithy_schema::ShapeType::String,
  127         -
    "default_version_id",
         127  +
    "DefaultVersionId",
  128    128   
    4,
  129    129   
);
  130    130   
static POLICY_MEMBER_ATTACHMENT_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$AttachmentCount", "com.amazonaws.iam", "Policy"),
  132    132   
    ::aws_smithy_schema::ShapeType::Integer,
  133         -
    "attachment_count",
         133  +
    "AttachmentCount",
  134    134   
    5,
  135    135   
);
  136    136   
static POLICY_MEMBER_PERMISSIONS_BOUNDARY_USAGE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$PermissionsBoundaryUsageCount", "com.amazonaws.iam", "Policy"),
  138    138   
    ::aws_smithy_schema::ShapeType::Integer,
  139         -
    "permissions_boundary_usage_count",
         139  +
    "PermissionsBoundaryUsageCount",
  140    140   
    6,
  141    141   
);
  142    142   
static POLICY_MEMBER_IS_ATTACHABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  143    143   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$IsAttachable", "com.amazonaws.iam", "Policy"),
  144    144   
    ::aws_smithy_schema::ShapeType::Boolean,
  145         -
    "is_attachable",
         145  +
    "IsAttachable",
  146    146   
    7,
  147    147   
);
  148    148   
static POLICY_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  149    149   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$Description", "com.amazonaws.iam", "Policy"),
  150    150   
    ::aws_smithy_schema::ShapeType::String,
  151         -
    "description",
         151  +
    "Description",
  152    152   
    8,
  153    153   
);
  154    154   
static POLICY_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$CreateDate", "com.amazonaws.iam", "Policy"),
  156    156   
    ::aws_smithy_schema::ShapeType::Timestamp,
  157         -
    "create_date",
         157  +
    "CreateDate",
  158    158   
    9,
  159    159   
);
  160    160   
static POLICY_MEMBER_UPDATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  161    161   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$UpdateDate", "com.amazonaws.iam", "Policy"),
  162    162   
    ::aws_smithy_schema::ShapeType::Timestamp,
  163         -
    "update_date",
         163  +
    "UpdateDate",
  164    164   
    10,
  165    165   
);
  166    166   
static POLICY_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Policy$Tags", "com.amazonaws.iam", "Policy"),
  168    168   
    ::aws_smithy_schema::ShapeType::List,
  169         -
    "tags",
         169  +
    "Tags",
  170    170   
    11,
  171    171   
);
  172    172   
static POLICY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  173    173   
    POLICY_SCHEMA_ID,
  174    174   
    ::aws_smithy_schema::ShapeType::Structure,
  175    175   
    &[
  176    176   
        &POLICY_MEMBER_POLICY_NAME,
  177    177   
        &POLICY_MEMBER_POLICY_ID,
  178    178   
        &POLICY_MEMBER_ARN,
  179    179   
        &POLICY_MEMBER_PATH,
@@ -217,217 +343,351 @@
  237    237   
                    ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  238    238   
                }
  239    239   
                Ok(())
  240    240   
            })?;
  241    241   
        }
  242    242   
        Ok(())
  243    243   
    }
  244    244   
}
  245    245   
impl Policy {
  246    246   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  247         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  248         -
        deserializer: &mut D,
         247  +
    pub fn deserialize(
         248  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  249    249   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  250    250   
        #[allow(unused_variables, unused_mut)]
  251    251   
        let mut builder = Self::builder();
  252    252   
        #[allow(
  253    253   
            unused_variables,
  254    254   
            unreachable_code,
  255    255   
            clippy::single_match,
  256    256   
            clippy::match_single_binding,
  257    257   
            clippy::diverging_sub_expression
  258    258   
        )]
  259         -
        deserializer.read_struct(&POLICY_SCHEMA, (), |_, member, deser| {
         259  +
        deserializer.read_struct(&POLICY_SCHEMA, &mut |member, deser| {
  260    260   
            match member.member_index() {
  261    261   
                Some(0) => {
  262    262   
                    builder.policy_name = Some(deser.read_string(member)?);
  263    263   
                }
  264    264   
                Some(1) => {
  265    265   
                    builder.policy_id = Some(deser.read_string(member)?);
  266    266   
                }
  267    267   
                Some(2) => {
  268    268   
                    builder.arn = Some(deser.read_string(member)?);
  269    269   
                }
  270    270   
                Some(3) => {
  271    271   
                    builder.path = Some(deser.read_string(member)?);
  272    272   
                }
  273    273   
                Some(4) => {
  274    274   
                    builder.default_version_id = Some(deser.read_string(member)?);
  275    275   
                }
  276    276   
                Some(5) => {
  277    277   
                    builder.attachment_count = Some(deser.read_integer(member)?);
  278    278   
                }
  279    279   
                Some(6) => {
  280    280   
                    builder.permissions_boundary_usage_count = Some(deser.read_integer(member)?);
  281    281   
                }
  282    282   
                Some(7) => {
  283    283   
                    builder.is_attachable = Some(deser.read_boolean(member)?);
  284    284   
                }
  285    285   
                Some(8) => {
  286    286   
                    builder.description = Some(deser.read_string(member)?);
  287    287   
                }
  288    288   
                Some(9) => {
  289    289   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  290    290   
                }
  291    291   
                Some(10) => {
  292    292   
                    builder.update_date = Some(deser.read_timestamp(member)?);
  293    293   
                }
  294    294   
                Some(11) => {
  295    295   
                    builder.tags = Some({
  296         -
                        let container = if let Some(cap) = deser.container_size() {
  297         -
                            Vec::with_capacity(cap)
  298         -
                        } else {
  299         -
                            Vec::new()
  300         -
                        };
  301         -
                        deser.read_list(member, container, |mut list, deser| {
  302         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  303         -
                            Ok(list)
  304         -
                        })?
         296  +
                        let mut container = Vec::new();
         297  +
                        deser.read_list(member, &mut |deser| {
         298  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         299  +
                            Ok(())
         300  +
                        })?;
         301  +
                        container
  305    302   
                    });
  306    303   
                }
  307    304   
                _ => {}
  308    305   
            }
  309    306   
            Ok(())
  310    307   
        })?;
  311    308   
        Ok(builder.build())
  312    309   
    }
  313    310   
}
         311  +
impl Policy {
         312  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         313  +
    pub fn deserialize_with_response(
         314  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         315  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         316  +
        _status: u16,
         317  +
        _body: &[u8],
         318  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         319  +
        Self::deserialize(deserializer)
         320  +
    }
         321  +
}
  314    322   
impl Policy {
  315    323   
    /// Creates a new builder-style object to manufacture [`Policy`](crate::types::Policy).
  316    324   
    pub fn builder() -> crate::types::builders::PolicyBuilder {
  317    325   
        crate::types::builders::PolicyBuilder::default()
  318    326   
    }
  319    327   
}
  320    328   
  321    329   
/// A builder for [`Policy`](crate::types::Policy).
  322    330   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  323    331   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_policy_detail.rs

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_policy_granting_service_access.rs

@@ -30,30 +213,225 @@
   50     50   
    "com.amazonaws.iam",
   51     51   
    "PolicyGrantingServiceAccess",
   52     52   
);
   53     53   
static POLICYGRANTINGSERVICEACCESS_MEMBER_POLICY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.iam#PolicyGrantingServiceAccess$PolicyName",
   56     56   
        "com.amazonaws.iam",
   57     57   
        "PolicyGrantingServiceAccess",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "policy_name",
          60  +
    "PolicyName",
   61     61   
    0,
   62     62   
);
   63     63   
static POLICYGRANTINGSERVICEACCESS_MEMBER_POLICY_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.iam#PolicyGrantingServiceAccess$PolicyType",
   66     66   
        "com.amazonaws.iam",
   67     67   
        "PolicyGrantingServiceAccess",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "policy_type",
          70  +
    "PolicyType",
   71     71   
    1,
   72     72   
);
   73     73   
static POLICYGRANTINGSERVICEACCESS_MEMBER_POLICY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.iam#PolicyGrantingServiceAccess$PolicyArn",
   76     76   
        "com.amazonaws.iam",
   77     77   
        "PolicyGrantingServiceAccess",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "policy_arn",
          80  +
    "PolicyArn",
   81     81   
    2,
   82     82   
);
   83     83   
static POLICYGRANTINGSERVICEACCESS_MEMBER_ENTITY_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.iam#PolicyGrantingServiceAccess$EntityType",
   86     86   
        "com.amazonaws.iam",
   87     87   
        "PolicyGrantingServiceAccess",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "entity_type",
          90  +
    "EntityType",
   91     91   
    3,
   92     92   
);
   93     93   
static POLICYGRANTINGSERVICEACCESS_MEMBER_ENTITY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.iam#PolicyGrantingServiceAccess$EntityName",
   96     96   
        "com.amazonaws.iam",
   97     97   
        "PolicyGrantingServiceAccess",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "entity_name",
         100  +
    "EntityName",
  101    101   
    4,
  102    102   
);
  103    103   
static POLICYGRANTINGSERVICEACCESS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  104    104   
    POLICYGRANTINGSERVICEACCESS_SCHEMA_ID,
  105    105   
    ::aws_smithy_schema::ShapeType::Structure,
  106    106   
    &[
  107    107   
        &POLICYGRANTINGSERVICEACCESS_MEMBER_POLICY_NAME,
  108    108   
        &POLICYGRANTINGSERVICEACCESS_MEMBER_POLICY_TYPE,
  109    109   
        &POLICYGRANTINGSERVICEACCESS_MEMBER_POLICY_ARN,
  110    110   
        &POLICYGRANTINGSERVICEACCESS_MEMBER_ENTITY_TYPE,
  111    111   
        &POLICYGRANTINGSERVICEACCESS_MEMBER_ENTITY_NAME,
  112    112   
    ],
  113    113   
);
  114    114   
impl PolicyGrantingServiceAccess {
  115    115   
    /// The schema for this shape.
  116    116   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POLICYGRANTINGSERVICEACCESS_SCHEMA;
  117    117   
}
  118    118   
impl ::aws_smithy_schema::serde::SerializableStruct for PolicyGrantingServiceAccess {
  119    119   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  120    120   
    fn serialize_members(
  121    121   
        &self,
  122    122   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  123    123   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  124    124   
        {
  125    125   
            let val = &self.policy_name;
  126    126   
            ser.write_string(&POLICYGRANTINGSERVICEACCESS_MEMBER_POLICY_NAME, val)?;
  127    127   
        }
  128    128   
        {
  129    129   
            let val = &self.policy_type;
  130    130   
            ser.write_string(&POLICYGRANTINGSERVICEACCESS_MEMBER_POLICY_TYPE, val.as_str())?;
  131    131   
        }
  132    132   
        if let Some(ref val) = self.policy_arn {
  133    133   
            ser.write_string(&POLICYGRANTINGSERVICEACCESS_MEMBER_POLICY_ARN, val)?;
  134    134   
        }
  135    135   
        if let Some(ref val) = self.entity_type {
  136    136   
            ser.write_string(&POLICYGRANTINGSERVICEACCESS_MEMBER_ENTITY_TYPE, val.as_str())?;
  137    137   
        }
  138    138   
        if let Some(ref val) = self.entity_name {
  139    139   
            ser.write_string(&POLICYGRANTINGSERVICEACCESS_MEMBER_ENTITY_NAME, val)?;
  140    140   
        }
  141    141   
        Ok(())
  142    142   
    }
  143    143   
}
  144    144   
impl PolicyGrantingServiceAccess {
  145    145   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  146         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  147         -
        deserializer: &mut D,
         146  +
    pub fn deserialize(
         147  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  148    148   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  149    149   
        #[allow(unused_variables, unused_mut)]
  150    150   
        let mut builder = Self::builder();
  151    151   
        #[allow(
  152    152   
            unused_variables,
  153    153   
            unreachable_code,
  154    154   
            clippy::single_match,
  155    155   
            clippy::match_single_binding,
  156    156   
            clippy::diverging_sub_expression
  157    157   
        )]
  158         -
        deserializer.read_struct(&POLICYGRANTINGSERVICEACCESS_SCHEMA, (), |_, member, deser| {
         158  +
        deserializer.read_struct(&POLICYGRANTINGSERVICEACCESS_SCHEMA, &mut |member, deser| {
  159    159   
            match member.member_index() {
  160    160   
                Some(0) => {
  161    161   
                    builder.policy_name = Some(deser.read_string(member)?);
  162    162   
                }
  163    163   
                Some(1) => {
  164    164   
                    builder.policy_type = Some(crate::types::PolicyType::from(deser.read_string(member)?.as_str()));
  165    165   
                }
  166    166   
                Some(2) => {
  167    167   
                    builder.policy_arn = Some(deser.read_string(member)?);
  168    168   
                }
  169    169   
                Some(3) => {
  170    170   
                    builder.entity_type = Some(crate::types::PolicyOwnerEntityType::from(deser.read_string(member)?.as_str()));
  171    171   
                }
  172    172   
                Some(4) => {
  173    173   
                    builder.entity_name = Some(deser.read_string(member)?);
  174    174   
                }
  175    175   
                _ => {}
  176    176   
            }
  177    177   
            Ok(())
  178    178   
        })?;
         179  +
        builder.policy_name = builder.policy_name.or(Some(String::new()));
  179    180   
        builder
  180    181   
            .build()
  181    182   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  182    183   
    }
  183    184   
}
         185  +
impl PolicyGrantingServiceAccess {
         186  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         187  +
    pub fn deserialize_with_response(
         188  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         189  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         190  +
        _status: u16,
         191  +
        _body: &[u8],
         192  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         193  +
        Self::deserialize(deserializer)
         194  +
    }
         195  +
}
  184    196   
impl PolicyGrantingServiceAccess {
  185    197   
    /// Creates a new builder-style object to manufacture [`PolicyGrantingServiceAccess`](crate::types::PolicyGrantingServiceAccess).
  186    198   
    pub fn builder() -> crate::types::builders::PolicyGrantingServiceAccessBuilder {
  187    199   
        crate::types::builders::PolicyGrantingServiceAccessBuilder::default()
  188    200   
    }
  189    201   
}
  190    202   
  191    203   
/// A builder for [`PolicyGrantingServiceAccess`](crate::types::PolicyGrantingServiceAccess).
  192    204   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  193    205   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_policy_group.rs

@@ -1,1 +120,131 @@
   19     19   
    /// <p>The stable and unique string identifying the group. For more information about IDs, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html">IAM identifiers</a> in the <i>IAM User Guide</i>.</p>
   20     20   
    pub fn group_id(&self) -> ::std::option::Option<&str> {
   21     21   
        self.group_id.as_deref()
   22     22   
    }
   23     23   
}
   24     24   
static POLICYGROUP_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyGroup", "com.amazonaws.iam", "PolicyGroup");
   26     26   
static POLICYGROUP_MEMBER_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyGroup$GroupName", "com.amazonaws.iam", "PolicyGroup"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "group_name",
          29  +
    "GroupName",
   30     30   
    0,
   31     31   
);
   32     32   
static POLICYGROUP_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyGroup$GroupId", "com.amazonaws.iam", "PolicyGroup"),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "group_id",
          35  +
    "GroupId",
   36     36   
    1,
   37     37   
);
   38     38   
static POLICYGROUP_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    POLICYGROUP_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&POLICYGROUP_MEMBER_GROUP_NAME, &POLICYGROUP_MEMBER_GROUP_ID],
   42     42   
);
   43     43   
impl PolicyGroup {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POLICYGROUP_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for PolicyGroup {
   48     48   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   49     49   
    fn serialize_members(
   50     50   
        &self,
   51     51   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   52     52   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        if let Some(ref val) = self.group_name {
   54     54   
            ser.write_string(&POLICYGROUP_MEMBER_GROUP_NAME, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.group_id {
   57     57   
            ser.write_string(&POLICYGROUP_MEMBER_GROUP_ID, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl PolicyGroup {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&POLICYGROUP_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&POLICYGROUP_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.group_name = Some(deser.read_string(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.group_id = Some(deser.read_string(member)?);
   83     83   
                }
   84     84   
                _ => {}
   85     85   
            }
   86     86   
            Ok(())
   87     87   
        })?;
   88     88   
        Ok(builder.build())
   89     89   
    }
   90     90   
}
          91  +
impl PolicyGroup {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          93  +
    pub fn deserialize_with_response(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          95  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          96  +
        _status: u16,
          97  +
        _body: &[u8],
          98  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          99  +
        Self::deserialize(deserializer)
         100  +
    }
         101  +
}
   91    102   
impl PolicyGroup {
   92    103   
    /// Creates a new builder-style object to manufacture [`PolicyGroup`](crate::types::PolicyGroup).
   93    104   
    pub fn builder() -> crate::types::builders::PolicyGroupBuilder {
   94    105   
        crate::types::builders::PolicyGroupBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`PolicyGroup`](crate::types::PolicyGroup).
   99    110   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    111   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_policy_role.rs

@@ -1,1 +120,131 @@
   19     19   
    /// <p>The stable and unique string identifying the role. For more information about IDs, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html">IAM identifiers</a> in the <i>IAM User Guide</i>.</p>
   20     20   
    pub fn role_id(&self) -> ::std::option::Option<&str> {
   21     21   
        self.role_id.as_deref()
   22     22   
    }
   23     23   
}
   24     24   
static POLICYROLE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyRole", "com.amazonaws.iam", "PolicyRole");
   26     26   
static POLICYROLE_MEMBER_ROLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyRole$RoleName", "com.amazonaws.iam", "PolicyRole"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "role_name",
          29  +
    "RoleName",
   30     30   
    0,
   31     31   
);
   32     32   
static POLICYROLE_MEMBER_ROLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyRole$RoleId", "com.amazonaws.iam", "PolicyRole"),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "role_id",
          35  +
    "RoleId",
   36     36   
    1,
   37     37   
);
   38     38   
static POLICYROLE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    POLICYROLE_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&POLICYROLE_MEMBER_ROLE_NAME, &POLICYROLE_MEMBER_ROLE_ID],
   42     42   
);
   43     43   
impl PolicyRole {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POLICYROLE_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for PolicyRole {
   48     48   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   49     49   
    fn serialize_members(
   50     50   
        &self,
   51     51   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   52     52   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        if let Some(ref val) = self.role_name {
   54     54   
            ser.write_string(&POLICYROLE_MEMBER_ROLE_NAME, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.role_id {
   57     57   
            ser.write_string(&POLICYROLE_MEMBER_ROLE_ID, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl PolicyRole {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&POLICYROLE_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&POLICYROLE_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.role_name = Some(deser.read_string(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.role_id = Some(deser.read_string(member)?);
   83     83   
                }
   84     84   
                _ => {}
   85     85   
            }
   86     86   
            Ok(())
   87     87   
        })?;
   88     88   
        Ok(builder.build())
   89     89   
    }
   90     90   
}
          91  +
impl PolicyRole {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          93  +
    pub fn deserialize_with_response(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          95  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          96  +
        _status: u16,
          97  +
        _body: &[u8],
          98  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          99  +
        Self::deserialize(deserializer)
         100  +
    }
         101  +
}
   91    102   
impl PolicyRole {
   92    103   
    /// Creates a new builder-style object to manufacture [`PolicyRole`](crate::types::PolicyRole).
   93    104   
    pub fn builder() -> crate::types::builders::PolicyRoleBuilder {
   94    105   
        crate::types::builders::PolicyRoleBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`PolicyRole`](crate::types::PolicyRole).
   99    110   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    111   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/iam/src/types/_policy_user.rs

@@ -1,1 +120,131 @@
   19     19   
    /// <p>The stable and unique string identifying the user. For more information about IDs, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html">IAM identifiers</a> in the <i>IAM User Guide</i>.</p>
   20     20   
    pub fn user_id(&self) -> ::std::option::Option<&str> {
   21     21   
        self.user_id.as_deref()
   22     22   
    }
   23     23   
}
   24     24   
static POLICYUSER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyUser", "com.amazonaws.iam", "PolicyUser");
   26     26   
static POLICYUSER_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyUser$UserName", "com.amazonaws.iam", "PolicyUser"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "user_name",
          29  +
    "UserName",
   30     30   
    0,
   31     31   
);
   32     32   
static POLICYUSER_MEMBER_USER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyUser$UserId", "com.amazonaws.iam", "PolicyUser"),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "user_id",
          35  +
    "UserId",
   36     36   
    1,
   37     37   
);
   38     38   
static POLICYUSER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    POLICYUSER_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&POLICYUSER_MEMBER_USER_NAME, &POLICYUSER_MEMBER_USER_ID],
   42     42   
);
   43     43   
impl PolicyUser {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POLICYUSER_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for PolicyUser {
   48     48   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   49     49   
    fn serialize_members(
   50     50   
        &self,
   51     51   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   52     52   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   53     53   
        if let Some(ref val) = self.user_name {
   54     54   
            ser.write_string(&POLICYUSER_MEMBER_USER_NAME, val)?;
   55     55   
        }
   56     56   
        if let Some(ref val) = self.user_id {
   57     57   
            ser.write_string(&POLICYUSER_MEMBER_USER_ID, val)?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl PolicyUser {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&POLICYUSER_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&POLICYUSER_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.user_name = Some(deser.read_string(member)?);
   80     80   
                }
   81     81   
                Some(1) => {
   82     82   
                    builder.user_id = Some(deser.read_string(member)?);
   83     83   
                }
   84     84   
                _ => {}
   85     85   
            }
   86     86   
            Ok(())
   87     87   
        })?;
   88     88   
        Ok(builder.build())
   89     89   
    }
   90     90   
}
          91  +
impl PolicyUser {
          92  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          93  +
    pub fn deserialize_with_response(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          95  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          96  +
        _status: u16,
          97  +
        _body: &[u8],
          98  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          99  +
        Self::deserialize(deserializer)
         100  +
    }
         101  +
}
   91    102   
impl PolicyUser {
   92    103   
    /// Creates a new builder-style object to manufacture [`PolicyUser`](crate::types::PolicyUser).
   93    104   
    pub fn builder() -> crate::types::builders::PolicyUserBuilder {
   94    105   
        crate::types::builders::PolicyUserBuilder::default()
   95    106   
    }
   96    107   
}
   97    108   
   98    109   
/// A builder for [`PolicyUser`](crate::types::PolicyUser).
   99    110   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100    111   
#[non_exhaustive]