AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

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

@@ -16,16 +184,198 @@
   36     36   
}
   37     37   
static SSHPUBLICKEYMETADATA_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   38     38   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#SSHPublicKeyMetadata", "com.amazonaws.iam", "SSHPublicKeyMetadata");
   39     39   
static SSHPUBLICKEYMETADATA_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.iam#SSHPublicKeyMetadata$UserName",
   42     42   
        "com.amazonaws.iam",
   43     43   
        "SSHPublicKeyMetadata",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "user_name",
          46  +
    "UserName",
   47     47   
    0,
   48     48   
);
   49     49   
static SSHPUBLICKEYMETADATA_MEMBER_SSH_PUBLIC_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.iam#SSHPublicKeyMetadata$SSHPublicKeyId",
   52     52   
        "com.amazonaws.iam",
   53     53   
        "SSHPublicKeyMetadata",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "ssh_public_key_id",
          56  +
    "SSHPublicKeyId",
   57     57   
    1,
   58     58   
);
   59     59   
static SSHPUBLICKEYMETADATA_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.iam#SSHPublicKeyMetadata$Status",
   62     62   
        "com.amazonaws.iam",
   63     63   
        "SSHPublicKeyMetadata",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "status",
          66  +
    "Status",
   67     67   
    2,
   68     68   
);
   69     69   
static SSHPUBLICKEYMETADATA_MEMBER_UPLOAD_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.iam#SSHPublicKeyMetadata$UploadDate",
   72     72   
        "com.amazonaws.iam",
   73     73   
        "SSHPublicKeyMetadata",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Timestamp,
   76         -
    "upload_date",
          76  +
    "UploadDate",
   77     77   
    3,
   78     78   
);
   79     79   
static SSHPUBLICKEYMETADATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   80     80   
    SSHPUBLICKEYMETADATA_SCHEMA_ID,
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82     82   
    &[
   83     83   
        &SSHPUBLICKEYMETADATA_MEMBER_USER_NAME,
   84     84   
        &SSHPUBLICKEYMETADATA_MEMBER_SSH_PUBLIC_KEY_ID,
   85     85   
        &SSHPUBLICKEYMETADATA_MEMBER_STATUS,
   86     86   
        &SSHPUBLICKEYMETADATA_MEMBER_UPLOAD_DATE,
   87     87   
    ],
   88     88   
);
   89     89   
impl SshPublicKeyMetadata {
   90     90   
    /// The schema for this shape.
   91     91   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SSHPUBLICKEYMETADATA_SCHEMA;
   92     92   
}
   93     93   
impl ::aws_smithy_schema::serde::SerializableStruct for SshPublicKeyMetadata {
   94     94   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   95     95   
    fn serialize_members(
   96     96   
        &self,
   97     97   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   98     98   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        {
  100    100   
            let val = &self.user_name;
  101    101   
            ser.write_string(&SSHPUBLICKEYMETADATA_MEMBER_USER_NAME, val)?;
  102    102   
        }
  103    103   
        {
  104    104   
            let val = &self.ssh_public_key_id;
  105    105   
            ser.write_string(&SSHPUBLICKEYMETADATA_MEMBER_SSH_PUBLIC_KEY_ID, val)?;
  106    106   
        }
  107    107   
        {
  108    108   
            let val = &self.status;
  109    109   
            ser.write_string(&SSHPUBLICKEYMETADATA_MEMBER_STATUS, val.as_str())?;
  110    110   
        }
  111    111   
        {
  112    112   
            let val = &self.upload_date;
  113    113   
            ser.write_timestamp(&SSHPUBLICKEYMETADATA_MEMBER_UPLOAD_DATE, val)?;
  114    114   
        }
  115    115   
        Ok(())
  116    116   
    }
  117    117   
}
  118    118   
impl SshPublicKeyMetadata {
  119    119   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  120         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  121         -
        deserializer: &mut D,
         120  +
    pub fn deserialize(
         121  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  122    122   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  123    123   
        #[allow(unused_variables, unused_mut)]
  124    124   
        let mut builder = Self::builder();
  125    125   
        #[allow(
  126    126   
            unused_variables,
  127    127   
            unreachable_code,
  128    128   
            clippy::single_match,
  129    129   
            clippy::match_single_binding,
  130    130   
            clippy::diverging_sub_expression
  131    131   
        )]
  132         -
        deserializer.read_struct(&SSHPUBLICKEYMETADATA_SCHEMA, (), |_, member, deser| {
         132  +
        deserializer.read_struct(&SSHPUBLICKEYMETADATA_SCHEMA, &mut |member, deser| {
  133    133   
            match member.member_index() {
  134    134   
                Some(0) => {
  135    135   
                    builder.user_name = Some(deser.read_string(member)?);
  136    136   
                }
  137    137   
                Some(1) => {
  138    138   
                    builder.ssh_public_key_id = Some(deser.read_string(member)?);
  139    139   
                }
  140    140   
                Some(2) => {
  141    141   
                    builder.status = Some(crate::types::StatusType::from(deser.read_string(member)?.as_str()));
  142    142   
                }
  143    143   
                Some(3) => {
  144    144   
                    builder.upload_date = Some(deser.read_timestamp(member)?);
  145    145   
                }
  146    146   
                _ => {}
  147    147   
            }
  148    148   
            Ok(())
  149    149   
        })?;
         150  +
        builder.user_name = builder.user_name.or(Some(String::new()));
         151  +
        builder.ssh_public_key_id = builder.ssh_public_key_id.or(Some(String::new()));
         152  +
        builder.upload_date = builder.upload_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  150    153   
        builder
  151    154   
            .build()
  152    155   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  153    156   
    }
  154    157   
}
         158  +
impl SshPublicKeyMetadata {
         159  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         160  +
    pub fn deserialize_with_response(
         161  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         162  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         163  +
        _status: u16,
         164  +
        _body: &[u8],
         165  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         166  +
        Self::deserialize(deserializer)
         167  +
    }
         168  +
}
  155    169   
impl SshPublicKeyMetadata {
  156    170   
    /// Creates a new builder-style object to manufacture [`SshPublicKeyMetadata`](crate::types::SshPublicKeyMetadata).
  157    171   
    pub fn builder() -> crate::types::builders::SshPublicKeyMetadataBuilder {
  158    172   
        crate::types::builders::SshPublicKeyMetadataBuilder::default()
  159    173   
    }
  160    174   
}
  161    175   
  162    176   
/// A builder for [`SshPublicKeyMetadata`](crate::types::SshPublicKeyMetadata).
  163    177   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  164    178   
#[non_exhaustive]

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

@@ -10,10 +160,171 @@
   30     30   
    /// <p>The row and column of the end of a <code>Statement</code> in an IAM policy.</p>
   31     31   
    pub fn end_position(&self) -> ::std::option::Option<&crate::types::Position> {
   32     32   
        self.end_position.as_ref()
   33     33   
    }
   34     34   
}
   35     35   
static STATEMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   36     36   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Statement", "com.amazonaws.iam", "Statement");
   37     37   
static STATEMENT_MEMBER_SOURCE_POLICY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Statement$SourcePolicyId", "com.amazonaws.iam", "Statement"),
   39     39   
    ::aws_smithy_schema::ShapeType::String,
   40         -
    "source_policy_id",
          40  +
    "SourcePolicyId",
   41     41   
    0,
   42     42   
);
   43     43   
static STATEMENT_MEMBER_SOURCE_POLICY_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Statement$SourcePolicyType", "com.amazonaws.iam", "Statement"),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "source_policy_type",
          46  +
    "SourcePolicyType",
   47     47   
    1,
   48     48   
);
   49     49   
static STATEMENT_MEMBER_START_POSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Statement$StartPosition", "com.amazonaws.iam", "Statement"),
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52         -
    "start_position",
          52  +
    "StartPosition",
   53     53   
    2,
   54     54   
);
   55     55   
static STATEMENT_MEMBER_END_POSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Statement$EndPosition", "com.amazonaws.iam", "Statement"),
   57     57   
    ::aws_smithy_schema::ShapeType::Structure,
   58         -
    "end_position",
          58  +
    "EndPosition",
   59     59   
    3,
   60     60   
);
   61     61   
static STATEMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   62     62   
    STATEMENT_SCHEMA_ID,
   63     63   
    ::aws_smithy_schema::ShapeType::Structure,
   64     64   
    &[
   65     65   
        &STATEMENT_MEMBER_SOURCE_POLICY_ID,
   66     66   
        &STATEMENT_MEMBER_SOURCE_POLICY_TYPE,
   67     67   
        &STATEMENT_MEMBER_START_POSITION,
   68     68   
        &STATEMENT_MEMBER_END_POSITION,
   69     69   
    ],
   70     70   
);
   71     71   
impl Statement {
   72     72   
    /// The schema for this shape.
   73     73   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STATEMENT_SCHEMA;
   74     74   
}
   75     75   
impl ::aws_smithy_schema::serde::SerializableStruct for Statement {
   76     76   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   77     77   
    fn serialize_members(
   78     78   
        &self,
   79     79   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   80     80   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   81     81   
        if let Some(ref val) = self.source_policy_id {
   82     82   
            ser.write_string(&STATEMENT_MEMBER_SOURCE_POLICY_ID, val)?;
   83     83   
        }
   84     84   
        if let Some(ref val) = self.source_policy_type {
   85     85   
            ser.write_string(&STATEMENT_MEMBER_SOURCE_POLICY_TYPE, val.as_str())?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.start_position {
   88     88   
            ser.write_struct(&STATEMENT_MEMBER_START_POSITION, val)?;
   89     89   
        }
   90     90   
        if let Some(ref val) = self.end_position {
   91     91   
            ser.write_struct(&STATEMENT_MEMBER_END_POSITION, val)?;
   92     92   
        }
   93     93   
        Ok(())
   94     94   
    }
   95     95   
}
   96     96   
impl Statement {
   97     97   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   98         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   99         -
        deserializer: &mut D,
          98  +
    pub fn deserialize(
          99  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  100    100   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  101    101   
        #[allow(unused_variables, unused_mut)]
  102    102   
        let mut builder = Self::builder();
  103    103   
        #[allow(
  104    104   
            unused_variables,
  105    105   
            unreachable_code,
  106    106   
            clippy::single_match,
  107    107   
            clippy::match_single_binding,
  108    108   
            clippy::diverging_sub_expression
  109    109   
        )]
  110         -
        deserializer.read_struct(&STATEMENT_SCHEMA, (), |_, member, deser| {
         110  +
        deserializer.read_struct(&STATEMENT_SCHEMA, &mut |member, deser| {
  111    111   
            match member.member_index() {
  112    112   
                Some(0) => {
  113    113   
                    builder.source_policy_id = Some(deser.read_string(member)?);
  114    114   
                }
  115    115   
                Some(1) => {
  116    116   
                    builder.source_policy_type = Some(crate::types::PolicySourceType::from(deser.read_string(member)?.as_str()));
  117    117   
                }
  118    118   
                Some(2) => {
  119    119   
                    builder.start_position = Some(crate::types::Position::deserialize(deser)?);
  120    120   
                }
  121    121   
                Some(3) => {
  122    122   
                    builder.end_position = Some(crate::types::Position::deserialize(deser)?);
  123    123   
                }
  124    124   
                _ => {}
  125    125   
            }
  126    126   
            Ok(())
  127    127   
        })?;
  128    128   
        Ok(builder.build())
  129    129   
    }
  130    130   
}
         131  +
impl Statement {
         132  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         133  +
    pub fn deserialize_with_response(
         134  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         135  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         136  +
        _status: u16,
         137  +
        _body: &[u8],
         138  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         139  +
        Self::deserialize(deserializer)
         140  +
    }
         141  +
}
  131    142   
impl Statement {
  132    143   
    /// Creates a new builder-style object to manufacture [`Statement`](crate::types::Statement).
  133    144   
    pub fn builder() -> crate::types::builders::StatementBuilder {
  134    145   
        crate::types::builders::StatementBuilder::default()
  135    146   
    }
  136    147   
}
  137    148   
  138    149   
/// A builder for [`Statement`](crate::types::Statement).
  139    150   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  140    151   
#[non_exhaustive]

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

@@ -1,1 +123,136 @@
   18     18   
    /// <p>The value associated with this tag. For example, tags with a key name of <code>Department</code> could have values such as <code>Human Resources</code>, <code>Accounting</code>, and <code>Support</code>. Tags with a key name of <code>Cost Center</code> might have values that consist of the number associated with the different cost centers in your company. Typically, many resources have tags with the same key name but with different values.</p>
   19     19   
    pub fn value(&self) -> &str {
   20     20   
        use std::ops::Deref;
   21     21   
        self.value.deref()
   22     22   
    }
   23     23   
}
   24     24   
static TAG_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Tag", "com.amazonaws.iam", "Tag");
   25     25   
static TAG_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   26     26   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Tag$Key", "com.amazonaws.iam", "Tag"),
   27     27   
    ::aws_smithy_schema::ShapeType::String,
   28         -
    "key",
          28  +
    "Key",
   29     29   
    0,
   30     30   
);
   31     31   
static TAG_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Tag$Value", "com.amazonaws.iam", "Tag"),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "value",
          34  +
    "Value",
   35     35   
    1,
   36     36   
);
   37     37   
static TAG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   38     38   
    TAG_SCHEMA_ID,
   39     39   
    ::aws_smithy_schema::ShapeType::Structure,
   40     40   
    &[&TAG_MEMBER_KEY, &TAG_MEMBER_VALUE],
   41     41   
);
   42     42   
impl Tag {
   43     43   
    /// The schema for this shape.
   44     44   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TAG_SCHEMA;
   45     45   
}
   46     46   
impl ::aws_smithy_schema::serde::SerializableStruct for Tag {
   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   
        {
   53     53   
            let val = &self.key;
   54     54   
            ser.write_string(&TAG_MEMBER_KEY, val)?;
   55     55   
        }
   56     56   
        {
   57     57   
            let val = &self.value;
   58     58   
            ser.write_string(&TAG_MEMBER_VALUE, val)?;
   59     59   
        }
   60     60   
        Ok(())
   61     61   
    }
   62     62   
}
   63     63   
impl Tag {
   64     64   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   65         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   66         -
        deserializer: &mut D,
          65  +
    pub fn deserialize(
          66  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   67     67   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   68     68   
        #[allow(unused_variables, unused_mut)]
   69     69   
        let mut builder = Self::builder();
   70     70   
        #[allow(
   71     71   
            unused_variables,
   72     72   
            unreachable_code,
   73     73   
            clippy::single_match,
   74     74   
            clippy::match_single_binding,
   75     75   
            clippy::diverging_sub_expression
   76     76   
        )]
   77         -
        deserializer.read_struct(&TAG_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&TAG_SCHEMA, &mut |member, deser| {
   78     78   
            match member.member_index() {
   79     79   
                Some(0) => {
   80     80   
                    builder.key = Some(deser.read_string(member)?);
   81     81   
                }
   82     82   
                Some(1) => {
   83     83   
                    builder.value = Some(deser.read_string(member)?);
   84     84   
                }
   85     85   
                _ => {}
   86     86   
            }
   87     87   
            Ok(())
   88     88   
        })?;
          89  +
        builder.key = builder.key.or(Some(String::new()));
          90  +
        builder.value = builder.value.or(Some(String::new()));
   89     91   
        builder
   90     92   
            .build()
   91     93   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   92     94   
    }
   93     95   
}
          96  +
impl Tag {
          97  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          98  +
    pub fn deserialize_with_response(
          99  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         100  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         101  +
        _status: u16,
         102  +
        _body: &[u8],
         103  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         104  +
        Self::deserialize(deserializer)
         105  +
    }
         106  +
}
   94    107   
impl Tag {
   95    108   
    /// Creates a new builder-style object to manufacture [`Tag`](crate::types::Tag).
   96    109   
    pub fn builder() -> crate::types::builders::TagBuilder {
   97    110   
        crate::types::builders::TagBuilder::default()
   98    111   
    }
   99    112   
}
  100    113   
  101    114   
/// A builder for [`Tag`](crate::types::Tag).
  102    115   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  103    116   
#[non_exhaustive]

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

@@ -23,23 +185,196 @@
   43     43   
    "com.amazonaws.iam",
   44     44   
    "TrackedActionLastAccessed",
   45     45   
);
   46     46   
static TRACKEDACTIONLASTACCESSED_MEMBER_ACTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static(
   48     48   
        "com.amazonaws.iam#TrackedActionLastAccessed$ActionName",
   49     49   
        "com.amazonaws.iam",
   50     50   
        "TrackedActionLastAccessed",
   51     51   
    ),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "action_name",
          53  +
    "ActionName",
   54     54   
    0,
   55     55   
);
   56     56   
static TRACKEDACTIONLASTACCESSED_MEMBER_LAST_ACCESSED_ENTITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.iam#TrackedActionLastAccessed$LastAccessedEntity",
   59     59   
        "com.amazonaws.iam",
   60     60   
        "TrackedActionLastAccessed",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "last_accessed_entity",
          63  +
    "LastAccessedEntity",
   64     64   
    1,
   65     65   
);
   66     66   
static TRACKEDACTIONLASTACCESSED_MEMBER_LAST_ACCESSED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.iam#TrackedActionLastAccessed$LastAccessedTime",
   69     69   
        "com.amazonaws.iam",
   70     70   
        "TrackedActionLastAccessed",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::Timestamp,
   73         -
    "last_accessed_time",
          73  +
    "LastAccessedTime",
   74     74   
    2,
   75     75   
);
   76     76   
static TRACKEDACTIONLASTACCESSED_MEMBER_LAST_ACCESSED_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static(
   78     78   
        "com.amazonaws.iam#TrackedActionLastAccessed$LastAccessedRegion",
   79     79   
        "com.amazonaws.iam",
   80     80   
        "TrackedActionLastAccessed",
   81     81   
    ),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "last_accessed_region",
          83  +
    "LastAccessedRegion",
   84     84   
    3,
   85     85   
);
   86     86   
static TRACKEDACTIONLASTACCESSED_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   87     87   
    TRACKEDACTIONLASTACCESSED_SCHEMA_ID,
   88     88   
    ::aws_smithy_schema::ShapeType::Structure,
   89     89   
    &[
   90     90   
        &TRACKEDACTIONLASTACCESSED_MEMBER_ACTION_NAME,
   91     91   
        &TRACKEDACTIONLASTACCESSED_MEMBER_LAST_ACCESSED_ENTITY,
   92     92   
        &TRACKEDACTIONLASTACCESSED_MEMBER_LAST_ACCESSED_TIME,
   93     93   
        &TRACKEDACTIONLASTACCESSED_MEMBER_LAST_ACCESSED_REGION,
   94     94   
    ],
   95     95   
);
   96     96   
impl TrackedActionLastAccessed {
   97     97   
    /// The schema for this shape.
   98     98   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRACKEDACTIONLASTACCESSED_SCHEMA;
   99     99   
}
  100    100   
impl ::aws_smithy_schema::serde::SerializableStruct for TrackedActionLastAccessed {
  101    101   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  102    102   
    fn serialize_members(
  103    103   
        &self,
  104    104   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  105    105   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  106    106   
        if let Some(ref val) = self.action_name {
  107    107   
            ser.write_string(&TRACKEDACTIONLASTACCESSED_MEMBER_ACTION_NAME, val)?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.last_accessed_entity {
  110    110   
            ser.write_string(&TRACKEDACTIONLASTACCESSED_MEMBER_LAST_ACCESSED_ENTITY, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.last_accessed_time {
  113    113   
            ser.write_timestamp(&TRACKEDACTIONLASTACCESSED_MEMBER_LAST_ACCESSED_TIME, val)?;
  114    114   
        }
  115    115   
        if let Some(ref val) = self.last_accessed_region {
  116    116   
            ser.write_string(&TRACKEDACTIONLASTACCESSED_MEMBER_LAST_ACCESSED_REGION, val)?;
  117    117   
        }
  118    118   
        Ok(())
  119    119   
    }
  120    120   
}
  121    121   
impl TrackedActionLastAccessed {
  122    122   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  123         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  124         -
        deserializer: &mut D,
         123  +
    pub fn deserialize(
         124  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  125    125   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  126    126   
        #[allow(unused_variables, unused_mut)]
  127    127   
        let mut builder = Self::builder();
  128    128   
        #[allow(
  129    129   
            unused_variables,
  130    130   
            unreachable_code,
  131    131   
            clippy::single_match,
  132    132   
            clippy::match_single_binding,
  133    133   
            clippy::diverging_sub_expression
  134    134   
        )]
  135         -
        deserializer.read_struct(&TRACKEDACTIONLASTACCESSED_SCHEMA, (), |_, member, deser| {
         135  +
        deserializer.read_struct(&TRACKEDACTIONLASTACCESSED_SCHEMA, &mut |member, deser| {
  136    136   
            match member.member_index() {
  137    137   
                Some(0) => {
  138    138   
                    builder.action_name = Some(deser.read_string(member)?);
  139    139   
                }
  140    140   
                Some(1) => {
  141    141   
                    builder.last_accessed_entity = Some(deser.read_string(member)?);
  142    142   
                }
  143    143   
                Some(2) => {
  144    144   
                    builder.last_accessed_time = Some(deser.read_timestamp(member)?);
  145    145   
                }
  146    146   
                Some(3) => {
  147    147   
                    builder.last_accessed_region = Some(deser.read_string(member)?);
  148    148   
                }
  149    149   
                _ => {}
  150    150   
            }
  151    151   
            Ok(())
  152    152   
        })?;
  153    153   
        Ok(builder.build())
  154    154   
    }
  155    155   
}
         156  +
impl TrackedActionLastAccessed {
         157  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         158  +
    pub fn deserialize_with_response(
         159  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         160  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         161  +
        _status: u16,
         162  +
        _body: &[u8],
         163  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         164  +
        Self::deserialize(deserializer)
         165  +
    }
         166  +
}
  156    167   
impl TrackedActionLastAccessed {
  157    168   
    /// Creates a new builder-style object to manufacture [`TrackedActionLastAccessed`](crate::types::TrackedActionLastAccessed).
  158    169   
    pub fn builder() -> crate::types::builders::TrackedActionLastAccessedBuilder {
  159    170   
        crate::types::builders::TrackedActionLastAccessedBuilder::default()
  160    171   
    }
  161    172   
}
  162    173   
  163    174   
/// A builder for [`TrackedActionLastAccessed`](crate::types::TrackedActionLastAccessed).
  164    175   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  165    176   
#[non_exhaustive]

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

@@ -66,66 +168,168 @@
   86     86   
    /// 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()`.
   87     87   
    pub fn tags(&self) -> &[crate::types::Tag] {
   88     88   
        self.tags.as_deref().unwrap_or_default()
   89     89   
    }
   90     90   
}
   91     91   
static USER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#User", "com.amazonaws.iam", "User");
   93     93   
static USER_MEMBER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#User$Path", "com.amazonaws.iam", "User"),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "path",
          96  +
    "Path",
   97     97   
    0,
   98     98   
);
   99     99   
static USER_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#User$UserName", "com.amazonaws.iam", "User"),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102         -
    "user_name",
         102  +
    "UserName",
  103    103   
    1,
  104    104   
);
  105    105   
static USER_MEMBER_USER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#User$UserId", "com.amazonaws.iam", "User"),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "user_id",
         108  +
    "UserId",
  109    109   
    2,
  110    110   
);
  111    111   
static USER_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#User$Arn", "com.amazonaws.iam", "User"),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "arn",
         114  +
    "Arn",
  115    115   
    3,
  116    116   
);
  117    117   
static USER_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#User$CreateDate", "com.amazonaws.iam", "User"),
  119    119   
    ::aws_smithy_schema::ShapeType::Timestamp,
  120         -
    "create_date",
         120  +
    "CreateDate",
  121    121   
    4,
  122    122   
);
  123    123   
static USER_MEMBER_PASSWORD_LAST_USED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#User$PasswordLastUsed", "com.amazonaws.iam", "User"),
  125    125   
    ::aws_smithy_schema::ShapeType::Timestamp,
  126         -
    "password_last_used",
         126  +
    "PasswordLastUsed",
  127    127   
    5,
  128    128   
);
  129    129   
static USER_MEMBER_PERMISSIONS_BOUNDARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#User$PermissionsBoundary", "com.amazonaws.iam", "User"),
  131    131   
    ::aws_smithy_schema::ShapeType::Structure,
  132         -
    "permissions_boundary",
         132  +
    "PermissionsBoundary",
  133    133   
    6,
  134    134   
);
  135    135   
static USER_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#User$Tags", "com.amazonaws.iam", "User"),
  137    137   
    ::aws_smithy_schema::ShapeType::List,
  138         -
    "tags",
         138  +
    "Tags",
  139    139   
    7,
  140    140   
);
  141    141   
static USER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  142    142   
    USER_SCHEMA_ID,
  143    143   
    ::aws_smithy_schema::ShapeType::Structure,
  144    144   
    &[
  145    145   
        &USER_MEMBER_PATH,
  146    146   
        &USER_MEMBER_USER_NAME,
  147    147   
        &USER_MEMBER_USER_ID,
  148    148   
        &USER_MEMBER_ARN,
@@ -174,174 +290,303 @@
  194    194   
                    ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  195    195   
                }
  196    196   
                Ok(())
  197    197   
            })?;
  198    198   
        }
  199    199   
        Ok(())
  200    200   
    }
  201    201   
}
  202    202   
impl User {
  203    203   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  204         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  205         -
        deserializer: &mut D,
         204  +
    pub fn deserialize(
         205  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  206    206   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  207    207   
        #[allow(unused_variables, unused_mut)]
  208    208   
        let mut builder = Self::builder();
  209    209   
        #[allow(
  210    210   
            unused_variables,
  211    211   
            unreachable_code,
  212    212   
            clippy::single_match,
  213    213   
            clippy::match_single_binding,
  214    214   
            clippy::diverging_sub_expression
  215    215   
        )]
  216         -
        deserializer.read_struct(&USER_SCHEMA, (), |_, member, deser| {
         216  +
        deserializer.read_struct(&USER_SCHEMA, &mut |member, deser| {
  217    217   
            match member.member_index() {
  218    218   
                Some(0) => {
  219    219   
                    builder.path = Some(deser.read_string(member)?);
  220    220   
                }
  221    221   
                Some(1) => {
  222    222   
                    builder.user_name = Some(deser.read_string(member)?);
  223    223   
                }
  224    224   
                Some(2) => {
  225    225   
                    builder.user_id = Some(deser.read_string(member)?);
  226    226   
                }
  227    227   
                Some(3) => {
  228    228   
                    builder.arn = Some(deser.read_string(member)?);
  229    229   
                }
  230    230   
                Some(4) => {
  231    231   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  232    232   
                }
  233    233   
                Some(5) => {
  234    234   
                    builder.password_last_used = Some(deser.read_timestamp(member)?);
  235    235   
                }
  236    236   
                Some(6) => {
  237    237   
                    builder.permissions_boundary = Some(crate::types::AttachedPermissionsBoundary::deserialize(deser)?);
  238    238   
                }
  239    239   
                Some(7) => {
  240    240   
                    builder.tags = Some({
  241         -
                        let container = if let Some(cap) = deser.container_size() {
  242         -
                            Vec::with_capacity(cap)
  243         -
                        } else {
  244         -
                            Vec::new()
  245         -
                        };
  246         -
                        deser.read_list(member, container, |mut list, deser| {
  247         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  248         -
                            Ok(list)
  249         -
                        })?
         241  +
                        let mut container = Vec::new();
         242  +
                        deser.read_list(member, &mut |deser| {
         243  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         244  +
                            Ok(())
         245  +
                        })?;
         246  +
                        container
  250    247   
                    });
  251    248   
                }
  252    249   
                _ => {}
  253    250   
            }
  254    251   
            Ok(())
  255    252   
        })?;
         253  +
        builder.path = builder.path.or(Some(String::new()));
         254  +
        builder.user_name = builder.user_name.or(Some(String::new()));
         255  +
        builder.user_id = builder.user_id.or(Some(String::new()));
         256  +
        builder.arn = builder.arn.or(Some(String::new()));
         257  +
        builder.create_date = builder.create_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  256    258   
        builder
  257    259   
            .build()
  258    260   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  259    261   
    }
  260    262   
}
         263  +
impl User {
         264  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         265  +
    pub fn deserialize_with_response(
         266  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         267  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         268  +
        _status: u16,
         269  +
        _body: &[u8],
         270  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         271  +
        Self::deserialize(deserializer)
         272  +
    }
         273  +
}
  261    274   
impl User {
  262    275   
    /// Creates a new builder-style object to manufacture [`User`](crate::types::User).
  263    276   
    pub fn builder() -> crate::types::builders::UserBuilder {
  264    277   
        crate::types::builders::UserBuilder::default()
  265    278   
    }
  266    279   
}
  267    280   
  268    281   
/// A builder for [`User`](crate::types::User).
  269    282   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  270    283   
#[non_exhaustive]

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

@@ -58,58 +172,172 @@
   78     78   
    /// 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()`.
   79     79   
    pub fn tags(&self) -> &[crate::types::Tag] {
   80     80   
        self.tags.as_deref().unwrap_or_default()
   81     81   
    }
   82     82   
}
   83     83   
static USERDETAIL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   84     84   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail", "com.amazonaws.iam", "UserDetail");
   85     85   
static USERDETAIL_MEMBER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$Path", "com.amazonaws.iam", "UserDetail"),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "path",
          88  +
    "Path",
   89     89   
    0,
   90     90   
);
   91     91   
static USERDETAIL_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$UserName", "com.amazonaws.iam", "UserDetail"),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "user_name",
          94  +
    "UserName",
   95     95   
    1,
   96     96   
);
   97     97   
static USERDETAIL_MEMBER_USER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$UserId", "com.amazonaws.iam", "UserDetail"),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "user_id",
         100  +
    "UserId",
  101    101   
    2,
  102    102   
);
  103    103   
static USERDETAIL_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$Arn", "com.amazonaws.iam", "UserDetail"),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "arn",
         106  +
    "Arn",
  107    107   
    3,
  108    108   
);
  109    109   
static USERDETAIL_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$CreateDate", "com.amazonaws.iam", "UserDetail"),
  111    111   
    ::aws_smithy_schema::ShapeType::Timestamp,
  112         -
    "create_date",
         112  +
    "CreateDate",
  113    113   
    4,
  114    114   
);
  115    115   
static USERDETAIL_MEMBER_USER_POLICY_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$UserPolicyList", "com.amazonaws.iam", "UserDetail"),
  117    117   
    ::aws_smithy_schema::ShapeType::List,
  118         -
    "user_policy_list",
         118  +
    "UserPolicyList",
  119    119   
    5,
  120    120   
);
  121    121   
static USERDETAIL_MEMBER_GROUP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$GroupList", "com.amazonaws.iam", "UserDetail"),
  123    123   
    ::aws_smithy_schema::ShapeType::List,
  124         -
    "group_list",
         124  +
    "GroupList",
  125    125   
    6,
  126    126   
);
  127    127   
static USERDETAIL_MEMBER_ATTACHED_MANAGED_POLICIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$AttachedManagedPolicies", "com.amazonaws.iam", "UserDetail"),
  129    129   
    ::aws_smithy_schema::ShapeType::List,
  130         -
    "attached_managed_policies",
         130  +
    "AttachedManagedPolicies",
  131    131   
    7,
  132    132   
);
  133    133   
static USERDETAIL_MEMBER_PERMISSIONS_BOUNDARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$PermissionsBoundary", "com.amazonaws.iam", "UserDetail"),
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136         -
    "permissions_boundary",
         136  +
    "PermissionsBoundary",
  137    137   
    8,
  138    138   
);
  139    139   
static USERDETAIL_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#UserDetail$Tags", "com.amazonaws.iam", "UserDetail"),
  141    141   
    ::aws_smithy_schema::ShapeType::List,
  142         -
    "tags",
         142  +
    "Tags",
  143    143   
    9,
  144    144   
);
  145    145   
static USERDETAIL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  146    146   
    USERDETAIL_SCHEMA_ID,
  147    147   
    ::aws_smithy_schema::ShapeType::Structure,
  148    148   
    &[
  149    149   
        &USERDETAIL_MEMBER_PATH,
  150    150   
        &USERDETAIL_MEMBER_USER_NAME,
  151    151   
        &USERDETAIL_MEMBER_USER_ID,
  152    152   
        &USERDETAIL_MEMBER_ARN,
@@ -205,205 +355,347 @@
  225    225   
                    ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  226    226   
                }
  227    227   
                Ok(())
  228    228   
            })?;
  229    229   
        }
  230    230   
        Ok(())
  231    231   
    }
  232    232   
}
  233    233   
impl UserDetail {
  234    234   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  235         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  236         -
        deserializer: &mut D,
         235  +
    pub fn deserialize(
         236  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  237    237   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  238    238   
        #[allow(unused_variables, unused_mut)]
  239    239   
        let mut builder = Self::builder();
  240    240   
        #[allow(
  241    241   
            unused_variables,
  242    242   
            unreachable_code,
  243    243   
            clippy::single_match,
  244    244   
            clippy::match_single_binding,
  245    245   
            clippy::diverging_sub_expression
  246    246   
        )]
  247         -
        deserializer.read_struct(&USERDETAIL_SCHEMA, (), |_, member, deser| {
         247  +
        deserializer.read_struct(&USERDETAIL_SCHEMA, &mut |member, deser| {
  248    248   
            match member.member_index() {
  249    249   
                Some(0) => {
  250    250   
                    builder.path = Some(deser.read_string(member)?);
  251    251   
                }
  252    252   
                Some(1) => {
  253    253   
                    builder.user_name = Some(deser.read_string(member)?);
  254    254   
                }
  255    255   
                Some(2) => {
  256    256   
                    builder.user_id = Some(deser.read_string(member)?);
  257    257   
                }
  258    258   
                Some(3) => {
  259    259   
                    builder.arn = Some(deser.read_string(member)?);
  260    260   
                }
  261    261   
                Some(4) => {
  262    262   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  263    263   
                }
  264    264   
                Some(5) => {
  265    265   
                    builder.user_policy_list = Some({
  266         -
                        let container = if let Some(cap) = deser.container_size() {
  267         -
                            Vec::with_capacity(cap)
  268         -
                        } else {
  269         -
                            Vec::new()
  270         -
                        };
  271         -
                        deser.read_list(member, container, |mut list, deser| {
  272         -
                            list.push(crate::types::PolicyDetail::deserialize(deser)?);
  273         -
                            Ok(list)
  274         -
                        })?
         266  +
                        let mut container = Vec::new();
         267  +
                        deser.read_list(member, &mut |deser| {
         268  +
                            container.push(crate::types::PolicyDetail::deserialize(deser)?);
         269  +
                            Ok(())
         270  +
                        })?;
         271  +
                        container
  275    272   
                    });
  276    273   
                }
  277    274   
                Some(6) => {
  278         -
                    builder.group_list = Some({
  279         -
                        let container = if let Some(cap) = deser.container_size() {
  280         -
                            Vec::with_capacity(cap)
  281         -
                        } else {
  282         -
                            Vec::new()
  283         -
                        };
  284         -
                        deser.read_list(member, container, |mut list, deser| {
  285         -
                            list.push(deser.read_string(member)?);
  286         -
                            Ok(list)
  287         -
                        })?
  288         -
                    });
         275  +
                    builder.group_list = Some(deser.read_string_list(member)?);
  289    276   
                }
  290    277   
                Some(7) => {
  291    278   
                    builder.attached_managed_policies = Some({
  292         -
                        let container = if let Some(cap) = deser.container_size() {
  293         -
                            Vec::with_capacity(cap)
  294         -
                        } else {
  295         -
                            Vec::new()
  296         -
                        };
  297         -
                        deser.read_list(member, container, |mut list, deser| {
  298         -
                            list.push(crate::types::AttachedPolicy::deserialize(deser)?);
  299         -
                            Ok(list)
  300         -
                        })?
         279  +
                        let mut container = Vec::new();
         280  +
                        deser.read_list(member, &mut |deser| {
         281  +
                            container.push(crate::types::AttachedPolicy::deserialize(deser)?);
         282  +
                            Ok(())
         283  +
                        })?;
         284  +
                        container
  301    285   
                    });
  302    286   
                }
  303    287   
                Some(8) => {
  304    288   
                    builder.permissions_boundary = Some(crate::types::AttachedPermissionsBoundary::deserialize(deser)?);
  305    289   
                }
  306    290   
                Some(9) => {
  307    291   
                    builder.tags = Some({
  308         -
                        let container = if let Some(cap) = deser.container_size() {
  309         -
                            Vec::with_capacity(cap)
  310         -
                        } else {
  311         -
                            Vec::new()
  312         -
                        };
  313         -
                        deser.read_list(member, container, |mut list, deser| {
  314         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  315         -
                            Ok(list)
  316         -
                        })?
         292  +
                        let mut container = Vec::new();
         293  +
                        deser.read_list(member, &mut |deser| {
         294  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         295  +
                            Ok(())
         296  +
                        })?;
         297  +
                        container
  317    298   
                    });
  318    299   
                }
  319    300   
                _ => {}
  320    301   
            }
  321    302   
            Ok(())
  322    303   
        })?;
  323    304   
        Ok(builder.build())
  324    305   
    }
  325    306   
}
         307  +
impl UserDetail {
         308  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         309  +
    pub fn deserialize_with_response(
         310  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         311  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         312  +
        _status: u16,
         313  +
        _body: &[u8],
         314  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         315  +
        Self::deserialize(deserializer)
         316  +
    }
         317  +
}
  326    318   
impl UserDetail {
  327    319   
    /// Creates a new builder-style object to manufacture [`UserDetail`](crate::types::UserDetail).
  328    320   
    pub fn builder() -> crate::types::builders::UserDetailBuilder {
  329    321   
        crate::types::builders::UserDetailBuilder::default()
  330    322   
    }
  331    323   
}
  332    324   
  333    325   
/// A builder for [`UserDetail`](crate::types::UserDetail).
  334    326   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  335    327   
#[non_exhaustive]

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

@@ -36,36 +237,246 @@
   56     56   
        formatter.field("enable_date", &self.enable_date);
   57     57   
        formatter.field("tags", &self.tags);
   58     58   
        formatter.finish()
   59     59   
    }
   60     60   
}
   61     61   
static VIRTUALMFADEVICE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   62     62   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#VirtualMFADevice", "com.amazonaws.iam", "VirtualMFADevice");
   63     63   
static VIRTUALMFADEVICE_MEMBER_SERIAL_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#VirtualMFADevice$SerialNumber", "com.amazonaws.iam", "VirtualMFADevice"),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "serial_number",
          66  +
    "SerialNumber",
   67     67   
    0,
   68     68   
);
   69     69   
static VIRTUALMFADEVICE_MEMBER_BASE32_STRING_SEED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.iam#VirtualMFADevice$Base32StringSeed",
   72     72   
        "com.amazonaws.iam",
   73     73   
        "VirtualMFADevice",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Blob,
   76         -
    "base32_string_seed",
          76  +
    "Base32StringSeed",
   77     77   
    1,
   78     78   
);
   79     79   
static VIRTUALMFADEVICE_MEMBER_QR_CODE_PNG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#VirtualMFADevice$QRCodePNG", "com.amazonaws.iam", "VirtualMFADevice"),
   81     81   
    ::aws_smithy_schema::ShapeType::Blob,
   82         -
    "qr_code_png",
          82  +
    "QRCodePNG",
   83     83   
    2,
   84     84   
);
   85     85   
static VIRTUALMFADEVICE_MEMBER_USER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#VirtualMFADevice$User", "com.amazonaws.iam", "VirtualMFADevice"),
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88         -
    "user",
          88  +
    "User",
   89     89   
    3,
   90     90   
);
   91     91   
static VIRTUALMFADEVICE_MEMBER_ENABLE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#VirtualMFADevice$EnableDate", "com.amazonaws.iam", "VirtualMFADevice"),
   93     93   
    ::aws_smithy_schema::ShapeType::Timestamp,
   94         -
    "enable_date",
          94  +
    "EnableDate",
   95     95   
    4,
   96     96   
);
   97     97   
static VIRTUALMFADEVICE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#VirtualMFADevice$Tags", "com.amazonaws.iam", "VirtualMFADevice"),
   99     99   
    ::aws_smithy_schema::ShapeType::List,
  100         -
    "tags",
         100  +
    "Tags",
  101    101   
    5,
  102    102   
);
  103    103   
static VIRTUALMFADEVICE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  104    104   
    VIRTUALMFADEVICE_SCHEMA_ID,
  105    105   
    ::aws_smithy_schema::ShapeType::Structure,
  106    106   
    &[
  107    107   
        &VIRTUALMFADEVICE_MEMBER_SERIAL_NUMBER,
  108    108   
        &VIRTUALMFADEVICE_MEMBER_BASE32_STRING_SEED,
  109    109   
        &VIRTUALMFADEVICE_MEMBER_QR_CODE_PNG,
  110    110   
        &VIRTUALMFADEVICE_MEMBER_USER,
  111    111   
        &VIRTUALMFADEVICE_MEMBER_ENABLE_DATE,
  112    112   
        &VIRTUALMFADEVICE_MEMBER_TAGS,
  113    113   
    ],
  114    114   
);
  115    115   
impl VirtualMfaDevice {
  116    116   
    /// The schema for this shape.
  117    117   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VIRTUALMFADEVICE_SCHEMA;
  118    118   
}
  119    119   
impl ::aws_smithy_schema::serde::SerializableStruct for VirtualMfaDevice {
  120    120   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  121    121   
    fn serialize_members(
  122    122   
        &self,
  123    123   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  124    124   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  125    125   
        {
  126    126   
            let val = &self.serial_number;
  127    127   
            ser.write_string(&VIRTUALMFADEVICE_MEMBER_SERIAL_NUMBER, val)?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.base32_string_seed {
  130    130   
            ser.write_blob(&VIRTUALMFADEVICE_MEMBER_BASE32_STRING_SEED, val)?;
  131    131   
        }
  132    132   
        if let Some(ref val) = self.qr_code_png {
  133    133   
            ser.write_blob(&VIRTUALMFADEVICE_MEMBER_QR_CODE_PNG, val)?;
  134    134   
        }
  135    135   
        if let Some(ref val) = self.user {
  136    136   
            ser.write_struct(&VIRTUALMFADEVICE_MEMBER_USER, val)?;
  137    137   
        }
  138    138   
        if let Some(ref val) = self.enable_date {
  139    139   
            ser.write_timestamp(&VIRTUALMFADEVICE_MEMBER_ENABLE_DATE, val)?;
  140    140   
        }
  141    141   
        if let Some(ref val) = self.tags {
  142    142   
            ser.write_list(
  143    143   
                &VIRTUALMFADEVICE_MEMBER_TAGS,
  144    144   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  145    145   
                    for item in val {
  146    146   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  147    147   
                    }
  148    148   
                    Ok(())
  149    149   
                },
  150    150   
            )?;
  151    151   
        }
  152    152   
        Ok(())
  153    153   
    }
  154    154   
}
  155    155   
impl VirtualMfaDevice {
  156    156   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  157         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  158         -
        deserializer: &mut D,
         157  +
    pub fn deserialize(
         158  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  159    159   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  160    160   
        #[allow(unused_variables, unused_mut)]
  161    161   
        let mut builder = Self::builder();
  162    162   
        #[allow(
  163    163   
            unused_variables,
  164    164   
            unreachable_code,
  165    165   
            clippy::single_match,
  166    166   
            clippy::match_single_binding,
  167    167   
            clippy::diverging_sub_expression
  168    168   
        )]
  169         -
        deserializer.read_struct(&VIRTUALMFADEVICE_SCHEMA, (), |_, member, deser| {
         169  +
        deserializer.read_struct(&VIRTUALMFADEVICE_SCHEMA, &mut |member, deser| {
  170    170   
            match member.member_index() {
  171    171   
                Some(0) => {
  172    172   
                    builder.serial_number = Some(deser.read_string(member)?);
  173    173   
                }
  174    174   
                Some(1) => {
  175    175   
                    builder.base32_string_seed = Some(deser.read_blob(member)?);
  176    176   
                }
  177    177   
                Some(2) => {
  178    178   
                    builder.qr_code_png = Some(deser.read_blob(member)?);
  179    179   
                }
  180    180   
                Some(3) => {
  181    181   
                    builder.user = Some(crate::types::User::deserialize(deser)?);
  182    182   
                }
  183    183   
                Some(4) => {
  184    184   
                    builder.enable_date = Some(deser.read_timestamp(member)?);
  185    185   
                }
  186    186   
                Some(5) => {
  187    187   
                    builder.tags = Some({
  188         -
                        let container = if let Some(cap) = deser.container_size() {
  189         -
                            Vec::with_capacity(cap)
  190         -
                        } else {
  191         -
                            Vec::new()
  192         -
                        };
  193         -
                        deser.read_list(member, container, |mut list, deser| {
  194         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  195         -
                            Ok(list)
  196         -
                        })?
         188  +
                        let mut container = Vec::new();
         189  +
                        deser.read_list(member, &mut |deser| {
         190  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         191  +
                            Ok(())
         192  +
                        })?;
         193  +
                        container
  197    194   
                    });
  198    195   
                }
  199    196   
                _ => {}
  200    197   
            }
  201    198   
            Ok(())
  202    199   
        })?;
         200  +
        builder.serial_number = builder.serial_number.or(Some(String::new()));
  203    201   
        builder
  204    202   
            .build()
  205    203   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  206    204   
    }
  207    205   
}
         206  +
impl VirtualMfaDevice {
         207  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         208  +
    pub fn deserialize_with_response(
         209  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         210  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         211  +
        _status: u16,
         212  +
        _body: &[u8],
         213  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         214  +
        Self::deserialize(deserializer)
         215  +
    }
         216  +
}
  208    217   
impl VirtualMfaDevice {
  209    218   
    /// Creates a new builder-style object to manufacture [`VirtualMfaDevice`](crate::types::VirtualMfaDevice).
  210    219   
    pub fn builder() -> crate::types::builders::VirtualMfaDeviceBuilder {
  211    220   
        crate::types::builders::VirtualMfaDeviceBuilder::default()
  212    221   
    }
  213    222   
}
  214    223   
  215    224   
/// A builder for [`VirtualMfaDevice`](crate::types::VirtualMfaDevice).
  216    225   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  217    226   
#[non_exhaustive]

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

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.iam",
   14     14   
    "AccountNotManagementOrDelegatedAdministratorException",
   15     15   
);
   16     16   
static ACCOUNTNOTMANAGEMENTORDELEGATEDADMINISTRATOREXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.iam#AccountNotManagementOrDelegatedAdministratorException$Message",
   19     19   
        "com.amazonaws.iam",
   20     20   
        "AccountNotManagementOrDelegatedAdministratorException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static ACCOUNTNOTMANAGEMENTORDELEGATEDADMINISTRATOREXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    ACCOUNTNOTMANAGEMENTORDELEGATEDADMINISTRATOREXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&ACCOUNTNOTMANAGEMENTORDELEGATEDADMINISTRATOREXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl AccountNotManagementOrDelegatedAdministratorException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ACCOUNTNOTMANAGEMENTORDELEGATEDADMINISTRATOREXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for AccountNotManagementOrDelegatedAdministratorException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&ACCOUNTNOTMANAGEMENTORDELEGATEDADMINISTRATOREXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl AccountNotManagementOrDelegatedAdministratorException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&ACCOUNTNOTMANAGEMENTORDELEGATEDADMINISTRATOREXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&ACCOUNTNOTMANAGEMENTORDELEGATEDADMINISTRATOREXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl AccountNotManagementOrDelegatedAdministratorException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl AccountNotManagementOrDelegatedAdministratorException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for AccountNotManagementOrDelegatedAdministratorException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "AccountNotManagementOrDelegatedAdministratorException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

@@ -1,1 +102,113 @@
   13     13   
    "com.amazonaws.iam",
   14     14   
    "CallerIsNotManagementAccountException",
   15     15   
);
   16     16   
static CALLERISNOTMANAGEMENTACCOUNTEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   17     17   
    ::aws_smithy_schema::ShapeId::from_static(
   18     18   
        "com.amazonaws.iam#CallerIsNotManagementAccountException$Message",
   19     19   
        "com.amazonaws.iam",
   20     20   
        "CallerIsNotManagementAccountException",
   21     21   
    ),
   22     22   
    ::aws_smithy_schema::ShapeType::String,
   23         -
    "message",
          23  +
    "Message",
   24     24   
    0,
   25     25   
);
   26     26   
static CALLERISNOTMANAGEMENTACCOUNTEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   27     27   
    CALLERISNOTMANAGEMENTACCOUNTEXCEPTION_SCHEMA_ID,
   28     28   
    ::aws_smithy_schema::ShapeType::Structure,
   29     29   
    &[&CALLERISNOTMANAGEMENTACCOUNTEXCEPTION_MEMBER_MESSAGE],
   30     30   
);
   31     31   
impl CallerIsNotManagementAccountException {
   32     32   
    /// The schema for this shape.
   33     33   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CALLERISNOTMANAGEMENTACCOUNTEXCEPTION_SCHEMA;
   34     34   
}
   35     35   
impl ::aws_smithy_schema::serde::SerializableStruct for CallerIsNotManagementAccountException {
   36     36   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   37     37   
    fn serialize_members(
   38     38   
        &self,
   39     39   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   40     40   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   41     41   
        if let Some(ref val) = self.message {
   42     42   
            ser.write_string(&CALLERISNOTMANAGEMENTACCOUNTEXCEPTION_MEMBER_MESSAGE, val)?;
   43     43   
        }
   44     44   
        Ok(())
   45     45   
    }
   46     46   
}
   47     47   
impl CallerIsNotManagementAccountException {
   48     48   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   49         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   50         -
        deserializer: &mut D,
          49  +
    pub fn deserialize(
          50  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   51     51   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   52     52   
        #[allow(unused_variables, unused_mut)]
   53     53   
        let mut builder = Self::builder();
   54     54   
        #[allow(
   55     55   
            unused_variables,
   56     56   
            unreachable_code,
   57     57   
            clippy::single_match,
   58     58   
            clippy::match_single_binding,
   59     59   
            clippy::diverging_sub_expression
   60     60   
        )]
   61         -
        deserializer.read_struct(&CALLERISNOTMANAGEMENTACCOUNTEXCEPTION_SCHEMA, (), |_, member, deser| {
          61  +
        deserializer.read_struct(&CALLERISNOTMANAGEMENTACCOUNTEXCEPTION_SCHEMA, &mut |member, deser| {
   62     62   
            match member.member_index() {
   63     63   
                Some(0) => {
   64     64   
                    builder.message = Some(deser.read_string(member)?);
   65     65   
                }
   66     66   
                _ => {}
   67     67   
            }
   68     68   
            Ok(())
   69     69   
        })?;
   70     70   
        Ok(builder.build())
   71     71   
    }
   72     72   
}
          73  +
impl CallerIsNotManagementAccountException {
          74  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          75  +
    pub fn deserialize_with_response(
          76  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          77  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          78  +
        _status: u16,
          79  +
        _body: &[u8],
          80  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          81  +
        Self::deserialize(deserializer)
          82  +
    }
          83  +
}
   73     84   
impl CallerIsNotManagementAccountException {
   74     85   
    /// Returns the error message.
   75     86   
    pub fn message(&self) -> ::std::option::Option<&str> {
   76     87   
        self.message.as_deref()
   77     88   
    }
   78     89   
}
   79     90   
impl ::std::fmt::Display for CallerIsNotManagementAccountException {
   80     91   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   81     92   
        ::std::write!(f, "CallerIsNotManagementAccountException")?;
   82     93   
        if let ::std::option::Option::Some(inner_1) = &self.message {

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

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

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

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

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

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

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

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

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

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

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

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

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

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