AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

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

@@ -17,17 +168,179 @@
   37     37   
    /// <p>The date and time, in <a href="http://www.iso.org/iso/iso8601">ISO 8601 date-time format</a>, when the policy version was created.</p>
   38     38   
    pub fn create_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   39     39   
        self.create_date.as_ref()
   40     40   
    }
   41     41   
}
   42     42   
static POLICYVERSION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyVersion", "com.amazonaws.iam", "PolicyVersion");
   44     44   
static POLICYVERSION_MEMBER_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyVersion$Document", "com.amazonaws.iam", "PolicyVersion"),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "document",
          47  +
    "Document",
   48     48   
    0,
   49     49   
);
   50     50   
static POLICYVERSION_MEMBER_VERSION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyVersion$VersionId", "com.amazonaws.iam", "PolicyVersion"),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "version_id",
          53  +
    "VersionId",
   54     54   
    1,
   55     55   
);
   56     56   
static POLICYVERSION_MEMBER_IS_DEFAULT_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyVersion$IsDefaultVersion", "com.amazonaws.iam", "PolicyVersion"),
   58     58   
    ::aws_smithy_schema::ShapeType::Boolean,
   59         -
    "is_default_version",
          59  +
    "IsDefaultVersion",
   60     60   
    2,
   61     61   
);
   62     62   
static POLICYVERSION_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#PolicyVersion$CreateDate", "com.amazonaws.iam", "PolicyVersion"),
   64     64   
    ::aws_smithy_schema::ShapeType::Timestamp,
   65         -
    "create_date",
          65  +
    "CreateDate",
   66     66   
    3,
   67     67   
);
   68     68   
static POLICYVERSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    POLICYVERSION_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &POLICYVERSION_MEMBER_DOCUMENT,
   73     73   
        &POLICYVERSION_MEMBER_VERSION_ID,
   74     74   
        &POLICYVERSION_MEMBER_IS_DEFAULT_VERSION,
   75     75   
        &POLICYVERSION_MEMBER_CREATE_DATE,
   76     76   
    ],
   77     77   
);
   78     78   
impl PolicyVersion {
   79     79   
    /// The schema for this shape.
   80     80   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POLICYVERSION_SCHEMA;
   81     81   
}
   82     82   
impl ::aws_smithy_schema::serde::SerializableStruct for PolicyVersion {
   83     83   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   84     84   
    fn serialize_members(
   85     85   
        &self,
   86     86   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   87     87   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   88     88   
        if let Some(ref val) = self.document {
   89     89   
            ser.write_string(&POLICYVERSION_MEMBER_DOCUMENT, val)?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.version_id {
   92     92   
            ser.write_string(&POLICYVERSION_MEMBER_VERSION_ID, val)?;
   93     93   
        }
   94     94   
        {
   95     95   
            let val = &self.is_default_version;
   96     96   
            ser.write_boolean(&POLICYVERSION_MEMBER_IS_DEFAULT_VERSION, *val)?;
   97     97   
        }
   98     98   
        if let Some(ref val) = self.create_date {
   99     99   
            ser.write_timestamp(&POLICYVERSION_MEMBER_CREATE_DATE, val)?;
  100    100   
        }
  101    101   
        Ok(())
  102    102   
    }
  103    103   
}
  104    104   
impl PolicyVersion {
  105    105   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  106         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  107         -
        deserializer: &mut D,
         106  +
    pub fn deserialize(
         107  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  108    108   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  109    109   
        #[allow(unused_variables, unused_mut)]
  110    110   
        let mut builder = Self::builder();
  111    111   
        #[allow(
  112    112   
            unused_variables,
  113    113   
            unreachable_code,
  114    114   
            clippy::single_match,
  115    115   
            clippy::match_single_binding,
  116    116   
            clippy::diverging_sub_expression
  117    117   
        )]
  118         -
        deserializer.read_struct(&POLICYVERSION_SCHEMA, (), |_, member, deser| {
         118  +
        deserializer.read_struct(&POLICYVERSION_SCHEMA, &mut |member, deser| {
  119    119   
            match member.member_index() {
  120    120   
                Some(0) => {
  121    121   
                    builder.document = Some(deser.read_string(member)?);
  122    122   
                }
  123    123   
                Some(1) => {
  124    124   
                    builder.version_id = Some(deser.read_string(member)?);
  125    125   
                }
  126    126   
                Some(2) => {
  127    127   
                    builder.is_default_version = Some(deser.read_boolean(member)?);
  128    128   
                }
  129    129   
                Some(3) => {
  130    130   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  131    131   
                }
  132    132   
                _ => {}
  133    133   
            }
  134    134   
            Ok(())
  135    135   
        })?;
  136    136   
        Ok(builder.build())
  137    137   
    }
  138    138   
}
         139  +
impl PolicyVersion {
         140  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         141  +
    pub fn deserialize_with_response(
         142  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         143  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         144  +
        _status: u16,
         145  +
        _body: &[u8],
         146  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         147  +
        Self::deserialize(deserializer)
         148  +
    }
         149  +
}
  139    150   
impl PolicyVersion {
  140    151   
    /// Creates a new builder-style object to manufacture [`PolicyVersion`](crate::types::PolicyVersion).
  141    152   
    pub fn builder() -> crate::types::builders::PolicyVersionBuilder {
  142    153   
        crate::types::builders::PolicyVersionBuilder::default()
  143    154   
    }
  144    155   
}
  145    156   
  146    157   
/// A builder for [`PolicyVersion`](crate::types::PolicyVersion).
  147    158   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  148    159   
#[non_exhaustive]

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

@@ -1,1 +121,132 @@
   18     18   
    /// <p>The column in the line containing the specified position in the document.</p>
   19     19   
    pub fn column(&self) -> i32 {
   20     20   
        self.column
   21     21   
    }
   22     22   
}
   23     23   
static POSITION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   24     24   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Position", "com.amazonaws.iam", "Position");
   25     25   
static POSITION_MEMBER_LINE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   26     26   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Position$Line", "com.amazonaws.iam", "Position"),
   27     27   
    ::aws_smithy_schema::ShapeType::Integer,
   28         -
    "line",
          28  +
    "Line",
   29     29   
    0,
   30     30   
);
   31     31   
static POSITION_MEMBER_COLUMN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Position$Column", "com.amazonaws.iam", "Position"),
   33     33   
    ::aws_smithy_schema::ShapeType::Integer,
   34         -
    "column",
          34  +
    "Column",
   35     35   
    1,
   36     36   
);
   37     37   
static POSITION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   38     38   
    POSITION_SCHEMA_ID,
   39     39   
    ::aws_smithy_schema::ShapeType::Structure,
   40     40   
    &[&POSITION_MEMBER_LINE, &POSITION_MEMBER_COLUMN],
   41     41   
);
   42     42   
impl Position {
   43     43   
    /// The schema for this shape.
   44     44   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &POSITION_SCHEMA;
   45     45   
}
   46     46   
impl ::aws_smithy_schema::serde::SerializableStruct for Position {
   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.line;
   54     54   
            ser.write_integer(&POSITION_MEMBER_LINE, *val)?;
   55     55   
        }
   56     56   
        {
   57     57   
            let val = &self.column;
   58     58   
            ser.write_integer(&POSITION_MEMBER_COLUMN, *val)?;
   59     59   
        }
   60     60   
        Ok(())
   61     61   
    }
   62     62   
}
   63     63   
impl Position {
   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(&POSITION_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&POSITION_SCHEMA, &mut |member, deser| {
   78     78   
            match member.member_index() {
   79     79   
                Some(0) => {
   80     80   
                    builder.line = Some(deser.read_integer(member)?);
   81     81   
                }
   82     82   
                Some(1) => {
   83     83   
                    builder.column = Some(deser.read_integer(member)?);
   84     84   
                }
   85     85   
                _ => {}
   86     86   
            }
   87     87   
            Ok(())
   88     88   
        })?;
   89     89   
        Ok(builder.build())
   90     90   
    }
   91     91   
}
          92  +
impl Position {
          93  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          94  +
    pub fn deserialize_with_response(
          95  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          96  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          97  +
        _status: u16,
          98  +
        _body: &[u8],
          99  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         100  +
        Self::deserialize(deserializer)
         101  +
    }
         102  +
}
   92    103   
impl Position {
   93    104   
    /// Creates a new builder-style object to manufacture [`Position`](crate::types::Position).
   94    105   
    pub fn builder() -> crate::types::builders::PositionBuilder {
   95    106   
        crate::types::builders::PositionBuilder::default()
   96    107   
    }
   97    108   
}
   98    109   
   99    110   
/// A builder for [`Position`](crate::types::Position).
  100    111   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  101    112   
#[non_exhaustive]

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

@@ -33,33 +143,143 @@
   53     53   
}
   54     54   
static RESOURCESPECIFICRESULT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#ResourceSpecificResult", "com.amazonaws.iam", "ResourceSpecificResult");
   56     56   
static RESOURCESPECIFICRESULT_MEMBER_EVAL_RESOURCE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.iam#ResourceSpecificResult$EvalResourceName",
   59     59   
        "com.amazonaws.iam",
   60     60   
        "ResourceSpecificResult",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "eval_resource_name",
          63  +
    "EvalResourceName",
   64     64   
    0,
   65     65   
);
   66     66   
static RESOURCESPECIFICRESULT_MEMBER_EVAL_RESOURCE_DECISION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.iam#ResourceSpecificResult$EvalResourceDecision",
   69     69   
        "com.amazonaws.iam",
   70     70   
        "ResourceSpecificResult",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::String,
   73         -
    "eval_resource_decision",
          73  +
    "EvalResourceDecision",
   74     74   
    1,
   75     75   
);
   76     76   
static RESOURCESPECIFICRESULT_MEMBER_MATCHED_STATEMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static(
   78     78   
        "com.amazonaws.iam#ResourceSpecificResult$MatchedStatements",
   79     79   
        "com.amazonaws.iam",
   80     80   
        "ResourceSpecificResult",
   81     81   
    ),
   82     82   
    ::aws_smithy_schema::ShapeType::List,
   83         -
    "matched_statements",
          83  +
    "MatchedStatements",
   84     84   
    2,
   85     85   
);
   86     86   
static RESOURCESPECIFICRESULT_MEMBER_MISSING_CONTEXT_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.iam#ResourceSpecificResult$MissingContextValues",
   89     89   
        "com.amazonaws.iam",
   90     90   
        "ResourceSpecificResult",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::List,
   93         -
    "missing_context_values",
          93  +
    "MissingContextValues",
   94     94   
    3,
   95     95   
);
   96     96   
static RESOURCESPECIFICRESULT_MEMBER_EVAL_DECISION_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.iam#ResourceSpecificResult$EvalDecisionDetails",
   99     99   
        "com.amazonaws.iam",
  100    100   
        "ResourceSpecificResult",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::Map,
  103         -
    "eval_decision_details",
         103  +
    "EvalDecisionDetails",
  104    104   
    4,
  105    105   
);
  106    106   
static RESOURCESPECIFICRESULT_MEMBER_PERMISSIONS_BOUNDARY_DECISION_DETAIL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.iam#ResourceSpecificResult$PermissionsBoundaryDecisionDetail",
  109    109   
        "com.amazonaws.iam",
  110    110   
        "ResourceSpecificResult",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::Structure,
  113         -
    "permissions_boundary_decision_detail",
         113  +
    "PermissionsBoundaryDecisionDetail",
  114    114   
    5,
  115    115   
);
  116    116   
static RESOURCESPECIFICRESULT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  117    117   
    RESOURCESPECIFICRESULT_SCHEMA_ID,
  118    118   
    ::aws_smithy_schema::ShapeType::Structure,
  119    119   
    &[
  120    120   
        &RESOURCESPECIFICRESULT_MEMBER_EVAL_RESOURCE_NAME,
  121    121   
        &RESOURCESPECIFICRESULT_MEMBER_EVAL_RESOURCE_DECISION,
  122    122   
        &RESOURCESPECIFICRESULT_MEMBER_MATCHED_STATEMENTS,
  123    123   
        &RESOURCESPECIFICRESULT_MEMBER_MISSING_CONTEXT_VALUES,
@@ -158,158 +288,284 @@
  178    178   
            )?;
  179    179   
        }
  180    180   
        if let Some(ref val) = self.permissions_boundary_decision_detail {
  181    181   
            ser.write_struct(&RESOURCESPECIFICRESULT_MEMBER_PERMISSIONS_BOUNDARY_DECISION_DETAIL, val)?;
  182    182   
        }
  183    183   
        Ok(())
  184    184   
    }
  185    185   
}
  186    186   
impl ResourceSpecificResult {
  187    187   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  188         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  189         -
        deserializer: &mut D,
         188  +
    pub fn deserialize(
         189  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  190    190   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  191    191   
        #[allow(unused_variables, unused_mut)]
  192    192   
        let mut builder = Self::builder();
  193    193   
        #[allow(
  194    194   
            unused_variables,
  195    195   
            unreachable_code,
  196    196   
            clippy::single_match,
  197    197   
            clippy::match_single_binding,
  198    198   
            clippy::diverging_sub_expression
  199    199   
        )]
  200         -
        deserializer.read_struct(&RESOURCESPECIFICRESULT_SCHEMA, (), |_, member, deser| {
         200  +
        deserializer.read_struct(&RESOURCESPECIFICRESULT_SCHEMA, &mut |member, deser| {
  201    201   
            match member.member_index() {
  202    202   
                Some(0) => {
  203    203   
                    builder.eval_resource_name = Some(deser.read_string(member)?);
  204    204   
                }
  205    205   
                Some(1) => {
  206    206   
                    builder.eval_resource_decision = Some(crate::types::PolicyEvaluationDecisionType::from(deser.read_string(member)?.as_str()));
  207    207   
                }
  208    208   
                Some(2) => {
  209    209   
                    builder.matched_statements = Some({
  210         -
                        let container = if let Some(cap) = deser.container_size() {
  211         -
                            Vec::with_capacity(cap)
  212         -
                        } else {
  213         -
                            Vec::new()
  214         -
                        };
  215         -
                        deser.read_list(member, container, |mut list, deser| {
  216         -
                            list.push(crate::types::Statement::deserialize(deser)?);
  217         -
                            Ok(list)
  218         -
                        })?
         210  +
                        let mut container = Vec::new();
         211  +
                        deser.read_list(member, &mut |deser| {
         212  +
                            container.push(crate::types::Statement::deserialize(deser)?);
         213  +
                            Ok(())
         214  +
                        })?;
         215  +
                        container
  219    216   
                    });
  220    217   
                }
  221    218   
                Some(3) => {
  222         -
                    builder.missing_context_values = Some({
  223         -
                        let container = if let Some(cap) = deser.container_size() {
  224         -
                            Vec::with_capacity(cap)
  225         -
                        } else {
  226         -
                            Vec::new()
  227         -
                        };
  228         -
                        deser.read_list(member, container, |mut list, deser| {
  229         -
                            list.push(deser.read_string(member)?);
  230         -
                            Ok(list)
  231         -
                        })?
  232         -
                    });
         219  +
                    builder.missing_context_values = Some(deser.read_string_list(member)?);
  233    220   
                }
  234    221   
                Some(4) => {
  235    222   
                    builder.eval_decision_details = Some({
  236         -
                        let container = if let Some(cap) = deser.container_size() {
  237         -
                            std::collections::HashMap::with_capacity(cap)
  238         -
                        } else {
  239         -
                            std::collections::HashMap::new()
  240         -
                        };
  241         -
                        deser.read_map(member, container, |mut map, key, deser| {
  242         -
                            map.insert(key, crate::types::PolicyEvaluationDecisionType::from(deser.read_string(member)?.as_str()));
  243         -
                            Ok(map)
  244         -
                        })?
         223  +
                        let mut container = std::collections::HashMap::new();
         224  +
                        deser.read_map(member, &mut |key, deser| {
         225  +
                            container.insert(key, crate::types::PolicyEvaluationDecisionType::from(deser.read_string(member)?.as_str()));
         226  +
                            Ok(())
         227  +
                        })?;
         228  +
                        container
  245    229   
                    });
  246    230   
                }
  247    231   
                Some(5) => {
  248    232   
                    builder.permissions_boundary_decision_detail = Some(crate::types::PermissionsBoundaryDecisionDetail::deserialize(deser)?);
  249    233   
                }
  250    234   
                _ => {}
  251    235   
            }
  252    236   
            Ok(())
  253    237   
        })?;
         238  +
        builder.eval_resource_name = builder.eval_resource_name.or(Some(String::new()));
  254    239   
        builder
  255    240   
            .build()
  256    241   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  257    242   
    }
  258    243   
}
         244  +
impl ResourceSpecificResult {
         245  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         246  +
    pub fn deserialize_with_response(
         247  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         248  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         249  +
        _status: u16,
         250  +
        _body: &[u8],
         251  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         252  +
        Self::deserialize(deserializer)
         253  +
    }
         254  +
}
  259    255   
impl ResourceSpecificResult {
  260    256   
    /// Creates a new builder-style object to manufacture [`ResourceSpecificResult`](crate::types::ResourceSpecificResult).
  261    257   
    pub fn builder() -> crate::types::builders::ResourceSpecificResultBuilder {
  262    258   
        crate::types::builders::ResourceSpecificResultBuilder::default()
  263    259   
    }
  264    260   
}
  265    261   
  266    262   
/// A builder for [`ResourceSpecificResult`](crate::types::ResourceSpecificResult).
  267    263   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  268    264   
#[non_exhaustive]

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

@@ -59,59 +179,179 @@
   79     79   
    /// <p>Contains information about the last time that an IAM role was used. This includes the date and time and the Region in which the role was last used. Activity is only reported for the trailing 400 days. This period can be shorter if your Region began supporting these features within the last year. The role might have been used more than 400 days ago. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#access-advisor_tracking-period">Regions where data is tracked</a> in the <i>IAM user Guide</i>.</p>
   80     80   
    pub fn role_last_used(&self) -> ::std::option::Option<&crate::types::RoleLastUsed> {
   81     81   
        self.role_last_used.as_ref()
   82     82   
    }
   83     83   
}
   84     84   
static ROLE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   85     85   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role", "com.amazonaws.iam", "Role");
   86     86   
static ROLE_MEMBER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$Path", "com.amazonaws.iam", "Role"),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "path",
          89  +
    "Path",
   90     90   
    0,
   91     91   
);
   92     92   
static ROLE_MEMBER_ROLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$RoleName", "com.amazonaws.iam", "Role"),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "role_name",
          95  +
    "RoleName",
   96     96   
    1,
   97     97   
);
   98     98   
static ROLE_MEMBER_ROLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$RoleId", "com.amazonaws.iam", "Role"),
  100    100   
    ::aws_smithy_schema::ShapeType::String,
  101         -
    "role_id",
         101  +
    "RoleId",
  102    102   
    2,
  103    103   
);
  104    104   
static ROLE_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$Arn", "com.amazonaws.iam", "Role"),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "arn",
         107  +
    "Arn",
  108    108   
    3,
  109    109   
);
  110    110   
static ROLE_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$CreateDate", "com.amazonaws.iam", "Role"),
  112    112   
    ::aws_smithy_schema::ShapeType::Timestamp,
  113         -
    "create_date",
         113  +
    "CreateDate",
  114    114   
    4,
  115    115   
);
  116    116   
static ROLE_MEMBER_ASSUME_ROLE_POLICY_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$AssumeRolePolicyDocument", "com.amazonaws.iam", "Role"),
  118    118   
    ::aws_smithy_schema::ShapeType::String,
  119         -
    "assume_role_policy_document",
         119  +
    "AssumeRolePolicyDocument",
  120    120   
    5,
  121    121   
);
  122    122   
static ROLE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$Description", "com.amazonaws.iam", "Role"),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "description",
         125  +
    "Description",
  126    126   
    6,
  127    127   
);
  128    128   
static ROLE_MEMBER_MAX_SESSION_DURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$MaxSessionDuration", "com.amazonaws.iam", "Role"),
  130    130   
    ::aws_smithy_schema::ShapeType::Integer,
  131         -
    "max_session_duration",
         131  +
    "MaxSessionDuration",
  132    132   
    7,
  133    133   
);
  134    134   
static ROLE_MEMBER_PERMISSIONS_BOUNDARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$PermissionsBoundary", "com.amazonaws.iam", "Role"),
  136    136   
    ::aws_smithy_schema::ShapeType::Structure,
  137         -
    "permissions_boundary",
         137  +
    "PermissionsBoundary",
  138    138   
    8,
  139    139   
);
  140    140   
static ROLE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$Tags", "com.amazonaws.iam", "Role"),
  142    142   
    ::aws_smithy_schema::ShapeType::List,
  143         -
    "tags",
         143  +
    "Tags",
  144    144   
    9,
  145    145   
);
  146    146   
static ROLE_MEMBER_ROLE_LAST_USED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#Role$RoleLastUsed", "com.amazonaws.iam", "Role"),
  148    148   
    ::aws_smithy_schema::ShapeType::Structure,
  149         -
    "role_last_used",
         149  +
    "RoleLastUsed",
  150    150   
    10,
  151    151   
);
  152    152   
static ROLE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  153    153   
    ROLE_SCHEMA_ID,
  154    154   
    ::aws_smithy_schema::ShapeType::Structure,
  155    155   
    &[
  156    156   
        &ROLE_MEMBER_PATH,
  157    157   
        &ROLE_MEMBER_ROLE_NAME,
  158    158   
        &ROLE_MEMBER_ROLE_ID,
  159    159   
        &ROLE_MEMBER_ARN,
@@ -197,197 +322,335 @@
  217    217   
            })?;
  218    218   
        }
  219    219   
        if let Some(ref val) = self.role_last_used {
  220    220   
            ser.write_struct(&ROLE_MEMBER_ROLE_LAST_USED, val)?;
  221    221   
        }
  222    222   
        Ok(())
  223    223   
    }
  224    224   
}
  225    225   
impl Role {
  226    226   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  227         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  228         -
        deserializer: &mut D,
         227  +
    pub fn deserialize(
         228  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  229    229   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  230    230   
        #[allow(unused_variables, unused_mut)]
  231    231   
        let mut builder = Self::builder();
  232    232   
        #[allow(
  233    233   
            unused_variables,
  234    234   
            unreachable_code,
  235    235   
            clippy::single_match,
  236    236   
            clippy::match_single_binding,
  237    237   
            clippy::diverging_sub_expression
  238    238   
        )]
  239         -
        deserializer.read_struct(&ROLE_SCHEMA, (), |_, member, deser| {
         239  +
        deserializer.read_struct(&ROLE_SCHEMA, &mut |member, deser| {
  240    240   
            match member.member_index() {
  241    241   
                Some(0) => {
  242    242   
                    builder.path = Some(deser.read_string(member)?);
  243    243   
                }
  244    244   
                Some(1) => {
  245    245   
                    builder.role_name = Some(deser.read_string(member)?);
  246    246   
                }
  247    247   
                Some(2) => {
  248    248   
                    builder.role_id = Some(deser.read_string(member)?);
  249    249   
                }
  250    250   
                Some(3) => {
  251    251   
                    builder.arn = Some(deser.read_string(member)?);
  252    252   
                }
  253    253   
                Some(4) => {
  254    254   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  255    255   
                }
  256    256   
                Some(5) => {
  257    257   
                    builder.assume_role_policy_document = Some(deser.read_string(member)?);
  258    258   
                }
  259    259   
                Some(6) => {
  260    260   
                    builder.description = Some(deser.read_string(member)?);
  261    261   
                }
  262    262   
                Some(7) => {
  263    263   
                    builder.max_session_duration = Some(deser.read_integer(member)?);
  264    264   
                }
  265    265   
                Some(8) => {
  266    266   
                    builder.permissions_boundary = Some(crate::types::AttachedPermissionsBoundary::deserialize(deser)?);
  267    267   
                }
  268    268   
                Some(9) => {
  269    269   
                    builder.tags = Some({
  270         -
                        let container = if let Some(cap) = deser.container_size() {
  271         -
                            Vec::with_capacity(cap)
  272         -
                        } else {
  273         -
                            Vec::new()
  274         -
                        };
  275         -
                        deser.read_list(member, container, |mut list, deser| {
  276         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  277         -
                            Ok(list)
  278         -
                        })?
         270  +
                        let mut container = Vec::new();
         271  +
                        deser.read_list(member, &mut |deser| {
         272  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         273  +
                            Ok(())
         274  +
                        })?;
         275  +
                        container
  279    276   
                    });
  280    277   
                }
  281    278   
                Some(10) => {
  282    279   
                    builder.role_last_used = Some(crate::types::RoleLastUsed::deserialize(deser)?);
  283    280   
                }
  284    281   
                _ => {}
  285    282   
            }
  286    283   
            Ok(())
  287    284   
        })?;
         285  +
        builder.path = builder.path.or(Some(String::new()));
         286  +
        builder.role_name = builder.role_name.or(Some(String::new()));
         287  +
        builder.role_id = builder.role_id.or(Some(String::new()));
         288  +
        builder.arn = builder.arn.or(Some(String::new()));
         289  +
        builder.create_date = builder.create_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  288    290   
        builder
  289    291   
            .build()
  290    292   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  291    293   
    }
  292    294   
}
         295  +
impl Role {
         296  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         297  +
    pub fn deserialize_with_response(
         298  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         299  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         300  +
        _status: u16,
         301  +
        _body: &[u8],
         302  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         303  +
        Self::deserialize(deserializer)
         304  +
    }
         305  +
}
  293    306   
impl Role {
  294    307   
    /// Creates a new builder-style object to manufacture [`Role`](crate::types::Role).
  295    308   
    pub fn builder() -> crate::types::builders::RoleBuilder {
  296    309   
        crate::types::builders::RoleBuilder::default()
  297    310   
    }
  298    311   
}
  299    312   
  300    313   
/// A builder for [`Role`](crate::types::Role).
  301    314   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  302    315   
#[non_exhaustive]

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

@@ -70,70 +196,196 @@
   90     90   
    /// <p>Contains information about the last time that an IAM role was used. This includes the date and time and the Region in which the role was last used. Activity is only reported for the trailing 400 days. This period can be shorter if your Region began supporting these features within the last year. The role might have been used more than 400 days ago. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#access-advisor_tracking-period">Regions where data is tracked</a> in the <i>IAM User Guide</i>.</p>
   91     91   
    pub fn role_last_used(&self) -> ::std::option::Option<&crate::types::RoleLastUsed> {
   92     92   
        self.role_last_used.as_ref()
   93     93   
    }
   94     94   
}
   95     95   
static ROLEDETAIL_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   96     96   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail", "com.amazonaws.iam", "RoleDetail");
   97     97   
static ROLEDETAIL_MEMBER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$Path", "com.amazonaws.iam", "RoleDetail"),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "path",
         100  +
    "Path",
  101    101   
    0,
  102    102   
);
  103    103   
static ROLEDETAIL_MEMBER_ROLE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$RoleName", "com.amazonaws.iam", "RoleDetail"),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "role_name",
         106  +
    "RoleName",
  107    107   
    1,
  108    108   
);
  109    109   
static ROLEDETAIL_MEMBER_ROLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$RoleId", "com.amazonaws.iam", "RoleDetail"),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "role_id",
         112  +
    "RoleId",
  113    113   
    2,
  114    114   
);
  115    115   
static ROLEDETAIL_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$Arn", "com.amazonaws.iam", "RoleDetail"),
  117    117   
    ::aws_smithy_schema::ShapeType::String,
  118         -
    "arn",
         118  +
    "Arn",
  119    119   
    3,
  120    120   
);
  121    121   
static ROLEDETAIL_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$CreateDate", "com.amazonaws.iam", "RoleDetail"),
  123    123   
    ::aws_smithy_schema::ShapeType::Timestamp,
  124         -
    "create_date",
         124  +
    "CreateDate",
  125    125   
    4,
  126    126   
);
  127    127   
static ROLEDETAIL_MEMBER_ASSUME_ROLE_POLICY_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$AssumeRolePolicyDocument", "com.amazonaws.iam", "RoleDetail"),
  129    129   
    ::aws_smithy_schema::ShapeType::String,
  130         -
    "assume_role_policy_document",
         130  +
    "AssumeRolePolicyDocument",
  131    131   
    5,
  132    132   
);
  133    133   
static ROLEDETAIL_MEMBER_INSTANCE_PROFILE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  134    134   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$InstanceProfileList", "com.amazonaws.iam", "RoleDetail"),
  135    135   
    ::aws_smithy_schema::ShapeType::List,
  136         -
    "instance_profile_list",
         136  +
    "InstanceProfileList",
  137    137   
    6,
  138    138   
);
  139    139   
static ROLEDETAIL_MEMBER_ROLE_POLICY_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$RolePolicyList", "com.amazonaws.iam", "RoleDetail"),
  141    141   
    ::aws_smithy_schema::ShapeType::List,
  142         -
    "role_policy_list",
         142  +
    "RolePolicyList",
  143    143   
    7,
  144    144   
);
  145    145   
static ROLEDETAIL_MEMBER_ATTACHED_MANAGED_POLICIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$AttachedManagedPolicies", "com.amazonaws.iam", "RoleDetail"),
  147    147   
    ::aws_smithy_schema::ShapeType::List,
  148         -
    "attached_managed_policies",
         148  +
    "AttachedManagedPolicies",
  149    149   
    8,
  150    150   
);
  151    151   
static ROLEDETAIL_MEMBER_PERMISSIONS_BOUNDARY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  152    152   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$PermissionsBoundary", "com.amazonaws.iam", "RoleDetail"),
  153    153   
    ::aws_smithy_schema::ShapeType::Structure,
  154         -
    "permissions_boundary",
         154  +
    "PermissionsBoundary",
  155    155   
    9,
  156    156   
);
  157    157   
static ROLEDETAIL_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$Tags", "com.amazonaws.iam", "RoleDetail"),
  159    159   
    ::aws_smithy_schema::ShapeType::List,
  160         -
    "tags",
         160  +
    "Tags",
  161    161   
    10,
  162    162   
);
  163    163   
static ROLEDETAIL_MEMBER_ROLE_LAST_USED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  164    164   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleDetail$RoleLastUsed", "com.amazonaws.iam", "RoleDetail"),
  165    165   
    ::aws_smithy_schema::ShapeType::Structure,
  166         -
    "role_last_used",
         166  +
    "RoleLastUsed",
  167    167   
    11,
  168    168   
);
  169    169   
static ROLEDETAIL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  170    170   
    ROLEDETAIL_SCHEMA_ID,
  171    171   
    ::aws_smithy_schema::ShapeType::Structure,
  172    172   
    &[
  173    173   
        &ROLEDETAIL_MEMBER_PATH,
  174    174   
        &ROLEDETAIL_MEMBER_ROLE_NAME,
  175    175   
        &ROLEDETAIL_MEMBER_ROLE_ID,
  176    176   
        &ROLEDETAIL_MEMBER_ARN,
@@ -237,237 +393,392 @@
  257    257   
            })?;
  258    258   
        }
  259    259   
        if let Some(ref val) = self.role_last_used {
  260    260   
            ser.write_struct(&ROLEDETAIL_MEMBER_ROLE_LAST_USED, val)?;
  261    261   
        }
  262    262   
        Ok(())
  263    263   
    }
  264    264   
}
  265    265   
impl RoleDetail {
  266    266   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  267         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  268         -
        deserializer: &mut D,
         267  +
    pub fn deserialize(
         268  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  269    269   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  270    270   
        #[allow(unused_variables, unused_mut)]
  271    271   
        let mut builder = Self::builder();
  272    272   
        #[allow(
  273    273   
            unused_variables,
  274    274   
            unreachable_code,
  275    275   
            clippy::single_match,
  276    276   
            clippy::match_single_binding,
  277    277   
            clippy::diverging_sub_expression
  278    278   
        )]
  279         -
        deserializer.read_struct(&ROLEDETAIL_SCHEMA, (), |_, member, deser| {
         279  +
        deserializer.read_struct(&ROLEDETAIL_SCHEMA, &mut |member, deser| {
  280    280   
            match member.member_index() {
  281    281   
                Some(0) => {
  282    282   
                    builder.path = Some(deser.read_string(member)?);
  283    283   
                }
  284    284   
                Some(1) => {
  285    285   
                    builder.role_name = Some(deser.read_string(member)?);
  286    286   
                }
  287    287   
                Some(2) => {
  288    288   
                    builder.role_id = Some(deser.read_string(member)?);
  289    289   
                }
  290    290   
                Some(3) => {
  291    291   
                    builder.arn = Some(deser.read_string(member)?);
  292    292   
                }
  293    293   
                Some(4) => {
  294    294   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  295    295   
                }
  296    296   
                Some(5) => {
  297    297   
                    builder.assume_role_policy_document = Some(deser.read_string(member)?);
  298    298   
                }
  299    299   
                Some(6) => {
  300    300   
                    builder.instance_profile_list = Some({
  301         -
                        let container = if let Some(cap) = deser.container_size() {
  302         -
                            Vec::with_capacity(cap)
  303         -
                        } else {
  304         -
                            Vec::new()
  305         -
                        };
  306         -
                        deser.read_list(member, container, |mut list, deser| {
  307         -
                            list.push(crate::types::InstanceProfile::deserialize(deser)?);
  308         -
                            Ok(list)
  309         -
                        })?
         301  +
                        let mut container = Vec::new();
         302  +
                        deser.read_list(member, &mut |deser| {
         303  +
                            container.push(crate::types::InstanceProfile::deserialize(deser)?);
         304  +
                            Ok(())
         305  +
                        })?;
         306  +
                        container
  310    307   
                    });
  311    308   
                }
  312    309   
                Some(7) => {
  313    310   
                    builder.role_policy_list = Some({
  314         -
                        let container = if let Some(cap) = deser.container_size() {
  315         -
                            Vec::with_capacity(cap)
  316         -
                        } else {
  317         -
                            Vec::new()
  318         -
                        };
  319         -
                        deser.read_list(member, container, |mut list, deser| {
  320         -
                            list.push(crate::types::PolicyDetail::deserialize(deser)?);
  321         -
                            Ok(list)
  322         -
                        })?
         311  +
                        let mut container = Vec::new();
         312  +
                        deser.read_list(member, &mut |deser| {
         313  +
                            container.push(crate::types::PolicyDetail::deserialize(deser)?);
         314  +
                            Ok(())
         315  +
                        })?;
         316  +
                        container
  323    317   
                    });
  324    318   
                }
  325    319   
                Some(8) => {
  326    320   
                    builder.attached_managed_policies = Some({
  327         -
                        let container = if let Some(cap) = deser.container_size() {
  328         -
                            Vec::with_capacity(cap)
  329         -
                        } else {
  330         -
                            Vec::new()
  331         -
                        };
  332         -
                        deser.read_list(member, container, |mut list, deser| {
  333         -
                            list.push(crate::types::AttachedPolicy::deserialize(deser)?);
  334         -
                            Ok(list)
  335         -
                        })?
         321  +
                        let mut container = Vec::new();
         322  +
                        deser.read_list(member, &mut |deser| {
         323  +
                            container.push(crate::types::AttachedPolicy::deserialize(deser)?);
         324  +
                            Ok(())
         325  +
                        })?;
         326  +
                        container
  336    327   
                    });
  337    328   
                }
  338    329   
                Some(9) => {
  339    330   
                    builder.permissions_boundary = Some(crate::types::AttachedPermissionsBoundary::deserialize(deser)?);
  340    331   
                }
  341    332   
                Some(10) => {
  342    333   
                    builder.tags = Some({
  343         -
                        let container = if let Some(cap) = deser.container_size() {
  344         -
                            Vec::with_capacity(cap)
  345         -
                        } else {
  346         -
                            Vec::new()
  347         -
                        };
  348         -
                        deser.read_list(member, container, |mut list, deser| {
  349         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  350         -
                            Ok(list)
  351         -
                        })?
         334  +
                        let mut container = Vec::new();
         335  +
                        deser.read_list(member, &mut |deser| {
         336  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         337  +
                            Ok(())
         338  +
                        })?;
         339  +
                        container
  352    340   
                    });
  353    341   
                }
  354    342   
                Some(11) => {
  355    343   
                    builder.role_last_used = Some(crate::types::RoleLastUsed::deserialize(deser)?);
  356    344   
                }
  357    345   
                _ => {}
  358    346   
            }
  359    347   
            Ok(())
  360    348   
        })?;
  361    349   
        Ok(builder.build())
  362    350   
    }
  363    351   
}
         352  +
impl RoleDetail {
         353  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         354  +
    pub fn deserialize_with_response(
         355  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         356  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         357  +
        _status: u16,
         358  +
        _body: &[u8],
         359  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         360  +
        Self::deserialize(deserializer)
         361  +
    }
         362  +
}
  364    363   
impl RoleDetail {
  365    364   
    /// Creates a new builder-style object to manufacture [`RoleDetail`](crate::types::RoleDetail).
  366    365   
    pub fn builder() -> crate::types::builders::RoleDetailBuilder {
  367    366   
        crate::types::builders::RoleDetailBuilder::default()
  368    367   
    }
  369    368   
}
  370    369   
  371    370   
/// A builder for [`RoleDetail`](crate::types::RoleDetail).
  372    371   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  373    372   
#[non_exhaustive]

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

@@ -1,1 +121,132 @@
   20     20   
    /// <p>The name of the Amazon Web Services Region in which the role was last used.</p>
   21     21   
    pub fn region(&self) -> ::std::option::Option<&str> {
   22     22   
        self.region.as_deref()
   23     23   
    }
   24     24   
}
   25     25   
static ROLELASTUSED_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   26     26   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleLastUsed", "com.amazonaws.iam", "RoleLastUsed");
   27     27   
static ROLELASTUSED_MEMBER_LAST_USED_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleLastUsed$LastUsedDate", "com.amazonaws.iam", "RoleLastUsed"),
   29     29   
    ::aws_smithy_schema::ShapeType::Timestamp,
   30         -
    "last_used_date",
          30  +
    "LastUsedDate",
   31     31   
    0,
   32     32   
);
   33     33   
static ROLELASTUSED_MEMBER_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleLastUsed$Region", "com.amazonaws.iam", "RoleLastUsed"),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "region",
          36  +
    "Region",
   37     37   
    1,
   38     38   
);
   39     39   
static ROLELASTUSED_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   40     40   
    ROLELASTUSED_SCHEMA_ID,
   41     41   
    ::aws_smithy_schema::ShapeType::Structure,
   42     42   
    &[&ROLELASTUSED_MEMBER_LAST_USED_DATE, &ROLELASTUSED_MEMBER_REGION],
   43     43   
);
   44     44   
impl RoleLastUsed {
   45     45   
    /// The schema for this shape.
   46     46   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROLELASTUSED_SCHEMA;
   47     47   
}
   48     48   
impl ::aws_smithy_schema::serde::SerializableStruct for RoleLastUsed {
   49     49   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   50     50   
    fn serialize_members(
   51     51   
        &self,
   52     52   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   53     53   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   54     54   
        if let Some(ref val) = self.last_used_date {
   55     55   
            ser.write_timestamp(&ROLELASTUSED_MEMBER_LAST_USED_DATE, val)?;
   56     56   
        }
   57     57   
        if let Some(ref val) = self.region {
   58     58   
            ser.write_string(&ROLELASTUSED_MEMBER_REGION, val)?;
   59     59   
        }
   60     60   
        Ok(())
   61     61   
    }
   62     62   
}
   63     63   
impl RoleLastUsed {
   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(&ROLELASTUSED_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&ROLELASTUSED_SCHEMA, &mut |member, deser| {
   78     78   
            match member.member_index() {
   79     79   
                Some(0) => {
   80     80   
                    builder.last_used_date = Some(deser.read_timestamp(member)?);
   81     81   
                }
   82     82   
                Some(1) => {
   83     83   
                    builder.region = Some(deser.read_string(member)?);
   84     84   
                }
   85     85   
                _ => {}
   86     86   
            }
   87     87   
            Ok(())
   88     88   
        })?;
   89     89   
        Ok(builder.build())
   90     90   
    }
   91     91   
}
          92  +
impl RoleLastUsed {
          93  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          94  +
    pub fn deserialize_with_response(
          95  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          96  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          97  +
        _status: u16,
          98  +
        _body: &[u8],
          99  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         100  +
        Self::deserialize(deserializer)
         101  +
    }
         102  +
}
   92    103   
impl RoleLastUsed {
   93    104   
    /// Creates a new builder-style object to manufacture [`RoleLastUsed`](crate::types::RoleLastUsed).
   94    105   
    pub fn builder() -> crate::types::builders::RoleLastUsedBuilder {
   95    106   
        crate::types::builders::RoleLastUsedBuilder::default()
   96    107   
    }
   97    108   
}
   98    109   
   99    110   
/// A builder for [`RoleLastUsed`](crate::types::RoleLastUsed).
  100    111   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  101    112   
#[non_exhaustive]

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

@@ -1,1 +139,140 @@
   20     20   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.resources.is_none()`.
   21     21   
    pub fn resources(&self) -> &[::std::string::String] {
   22     22   
        self.resources.as_deref().unwrap_or_default()
   23     23   
    }
   24     24   
}
   25     25   
static ROLEUSAGETYPE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   26     26   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleUsageType", "com.amazonaws.iam", "RoleUsageType");
   27     27   
static ROLEUSAGETYPE_MEMBER_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleUsageType$Region", "com.amazonaws.iam", "RoleUsageType"),
   29     29   
    ::aws_smithy_schema::ShapeType::String,
   30         -
    "region",
          30  +
    "Region",
   31     31   
    0,
   32     32   
);
   33     33   
static ROLEUSAGETYPE_MEMBER_RESOURCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#RoleUsageType$Resources", "com.amazonaws.iam", "RoleUsageType"),
   35     35   
    ::aws_smithy_schema::ShapeType::List,
   36         -
    "resources",
          36  +
    "Resources",
   37     37   
    1,
   38     38   
);
   39     39   
static ROLEUSAGETYPE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   40     40   
    ROLEUSAGETYPE_SCHEMA_ID,
   41     41   
    ::aws_smithy_schema::ShapeType::Structure,
   42     42   
    &[&ROLEUSAGETYPE_MEMBER_REGION, &ROLEUSAGETYPE_MEMBER_RESOURCES],
   43     43   
);
   44     44   
impl RoleUsageType {
   45     45   
    /// The schema for this shape.
   46     46   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROLEUSAGETYPE_SCHEMA;
   47     47   
}
   48     48   
impl ::aws_smithy_schema::serde::SerializableStruct for RoleUsageType {
   49     49   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   50     50   
    fn serialize_members(
   51     51   
        &self,
   52     52   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   53     53   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   54     54   
        if let Some(ref val) = self.region {
   55     55   
            ser.write_string(&ROLEUSAGETYPE_MEMBER_REGION, val)?;
   56     56   
        }
   57     57   
        if let Some(ref val) = self.resources {
   58     58   
            ser.write_list(
   59     59   
                &ROLEUSAGETYPE_MEMBER_RESOURCES,
   60     60   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   61     61   
                    for item in val {
   62     62   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   63     63   
                    }
   64     64   
                    Ok(())
   65     65   
                },
   66     66   
            )?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl RoleUsageType {
   72     72   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   73         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   74         -
        deserializer: &mut D,
          73  +
    pub fn deserialize(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   75     75   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   76     76   
        #[allow(unused_variables, unused_mut)]
   77     77   
        let mut builder = Self::builder();
   78     78   
        #[allow(
   79     79   
            unused_variables,
   80     80   
            unreachable_code,
   81     81   
            clippy::single_match,
   82     82   
            clippy::match_single_binding,
   83     83   
            clippy::diverging_sub_expression
   84     84   
        )]
   85         -
        deserializer.read_struct(&ROLEUSAGETYPE_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&ROLEUSAGETYPE_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.region = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91         -
                    builder.resources = Some({
   92         -
                        let container = if let Some(cap) = deser.container_size() {
   93         -
                            Vec::with_capacity(cap)
   94         -
                        } else {
   95         -
                            Vec::new()
   96         -
                        };
   97         -
                        deser.read_list(member, container, |mut list, deser| {
   98         -
                            list.push(deser.read_string(member)?);
   99         -
                            Ok(list)
  100         -
                        })?
  101         -
                    });
          91  +
                    builder.resources = Some(deser.read_string_list(member)?);
  102     92   
                }
  103     93   
                _ => {}
  104     94   
            }
  105     95   
            Ok(())
  106     96   
        })?;
  107     97   
        Ok(builder.build())
  108     98   
    }
  109     99   
}
         100  +
impl RoleUsageType {
         101  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         102  +
    pub fn deserialize_with_response(
         103  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         104  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         105  +
        _status: u16,
         106  +
        _body: &[u8],
         107  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         108  +
        Self::deserialize(deserializer)
         109  +
    }
         110  +
}
  110    111   
impl RoleUsageType {
  111    112   
    /// Creates a new builder-style object to manufacture [`RoleUsageType`](crate::types::RoleUsageType).
  112    113   
    pub fn builder() -> crate::types::builders::RoleUsageTypeBuilder {
  113    114   
        crate::types::builders::RoleUsageTypeBuilder::default()
  114    115   
    }
  115    116   
}
  116    117   
  117    118   
/// A builder for [`RoleUsageType`](crate::types::RoleUsageType).
  118    119   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  119    120   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -33,33 +235,250 @@
   53     53   
    "com.amazonaws.iam",
   54     54   
    "ServerCertificateMetadata",
   55     55   
);
   56     56   
static SERVERCERTIFICATEMETADATA_MEMBER_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.iam#ServerCertificateMetadata$Path",
   59     59   
        "com.amazonaws.iam",
   60     60   
        "ServerCertificateMetadata",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "path",
          63  +
    "Path",
   64     64   
    0,
   65     65   
);
   66     66   
static SERVERCERTIFICATEMETADATA_MEMBER_SERVER_CERTIFICATE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.iam#ServerCertificateMetadata$ServerCertificateName",
   69     69   
        "com.amazonaws.iam",
   70     70   
        "ServerCertificateMetadata",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::String,
   73         -
    "server_certificate_name",
          73  +
    "ServerCertificateName",
   74     74   
    1,
   75     75   
);
   76     76   
static SERVERCERTIFICATEMETADATA_MEMBER_SERVER_CERTIFICATE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static(
   78     78   
        "com.amazonaws.iam#ServerCertificateMetadata$ServerCertificateId",
   79     79   
        "com.amazonaws.iam",
   80     80   
        "ServerCertificateMetadata",
   81     81   
    ),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "server_certificate_id",
          83  +
    "ServerCertificateId",
   84     84   
    2,
   85     85   
);
   86     86   
static SERVERCERTIFICATEMETADATA_MEMBER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.iam#ServerCertificateMetadata$Arn",
   89     89   
        "com.amazonaws.iam",
   90     90   
        "ServerCertificateMetadata",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "arn",
          93  +
    "Arn",
   94     94   
    3,
   95     95   
);
   96     96   
static SERVERCERTIFICATEMETADATA_MEMBER_UPLOAD_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.iam#ServerCertificateMetadata$UploadDate",
   99     99   
        "com.amazonaws.iam",
  100    100   
        "ServerCertificateMetadata",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::Timestamp,
  103         -
    "upload_date",
         103  +
    "UploadDate",
  104    104   
    4,
  105    105   
);
  106    106   
static SERVERCERTIFICATEMETADATA_MEMBER_EXPIRATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.iam#ServerCertificateMetadata$Expiration",
  109    109   
        "com.amazonaws.iam",
  110    110   
        "ServerCertificateMetadata",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::Timestamp,
  113         -
    "expiration",
         113  +
    "Expiration",
  114    114   
    5,
  115    115   
);
  116    116   
static SERVERCERTIFICATEMETADATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  117    117   
    SERVERCERTIFICATEMETADATA_SCHEMA_ID,
  118    118   
    ::aws_smithy_schema::ShapeType::Structure,
  119    119   
    &[
  120    120   
        &SERVERCERTIFICATEMETADATA_MEMBER_PATH,
  121    121   
        &SERVERCERTIFICATEMETADATA_MEMBER_SERVER_CERTIFICATE_NAME,
  122    122   
        &SERVERCERTIFICATEMETADATA_MEMBER_SERVER_CERTIFICATE_ID,
  123    123   
        &SERVERCERTIFICATEMETADATA_MEMBER_ARN,
  124    124   
        &SERVERCERTIFICATEMETADATA_MEMBER_UPLOAD_DATE,
  125    125   
        &SERVERCERTIFICATEMETADATA_MEMBER_EXPIRATION,
  126    126   
    ],
  127    127   
);
  128    128   
impl ServerCertificateMetadata {
  129    129   
    /// The schema for this shape.
  130    130   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SERVERCERTIFICATEMETADATA_SCHEMA;
  131    131   
}
  132    132   
impl ::aws_smithy_schema::serde::SerializableStruct for ServerCertificateMetadata {
  133    133   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  134    134   
    fn serialize_members(
  135    135   
        &self,
  136    136   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  137    137   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  138    138   
        {
  139    139   
            let val = &self.path;
  140    140   
            ser.write_string(&SERVERCERTIFICATEMETADATA_MEMBER_PATH, val)?;
  141    141   
        }
  142    142   
        {
  143    143   
            let val = &self.server_certificate_name;
  144    144   
            ser.write_string(&SERVERCERTIFICATEMETADATA_MEMBER_SERVER_CERTIFICATE_NAME, val)?;
  145    145   
        }
  146    146   
        {
  147    147   
            let val = &self.server_certificate_id;
  148    148   
            ser.write_string(&SERVERCERTIFICATEMETADATA_MEMBER_SERVER_CERTIFICATE_ID, val)?;
  149    149   
        }
  150    150   
        {
  151    151   
            let val = &self.arn;
  152    152   
            ser.write_string(&SERVERCERTIFICATEMETADATA_MEMBER_ARN, val)?;
  153    153   
        }
  154    154   
        if let Some(ref val) = self.upload_date {
  155    155   
            ser.write_timestamp(&SERVERCERTIFICATEMETADATA_MEMBER_UPLOAD_DATE, val)?;
  156    156   
        }
  157    157   
        if let Some(ref val) = self.expiration {
  158    158   
            ser.write_timestamp(&SERVERCERTIFICATEMETADATA_MEMBER_EXPIRATION, val)?;
  159    159   
        }
  160    160   
        Ok(())
  161    161   
    }
  162    162   
}
  163    163   
impl ServerCertificateMetadata {
  164    164   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  165         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  166         -
        deserializer: &mut D,
         165  +
    pub fn deserialize(
         166  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  167    167   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  168    168   
        #[allow(unused_variables, unused_mut)]
  169    169   
        let mut builder = Self::builder();
  170    170   
        #[allow(
  171    171   
            unused_variables,
  172    172   
            unreachable_code,
  173    173   
            clippy::single_match,
  174    174   
            clippy::match_single_binding,
  175    175   
            clippy::diverging_sub_expression
  176    176   
        )]
  177         -
        deserializer.read_struct(&SERVERCERTIFICATEMETADATA_SCHEMA, (), |_, member, deser| {
         177  +
        deserializer.read_struct(&SERVERCERTIFICATEMETADATA_SCHEMA, &mut |member, deser| {
  178    178   
            match member.member_index() {
  179    179   
                Some(0) => {
  180    180   
                    builder.path = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(1) => {
  183    183   
                    builder.server_certificate_name = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                Some(2) => {
  186    186   
                    builder.server_certificate_id = Some(deser.read_string(member)?);
  187    187   
                }
  188    188   
                Some(3) => {
  189    189   
                    builder.arn = Some(deser.read_string(member)?);
  190    190   
                }
  191    191   
                Some(4) => {
  192    192   
                    builder.upload_date = Some(deser.read_timestamp(member)?);
  193    193   
                }
  194    194   
                Some(5) => {
  195    195   
                    builder.expiration = Some(deser.read_timestamp(member)?);
  196    196   
                }
  197    197   
                _ => {}
  198    198   
            }
  199    199   
            Ok(())
  200    200   
        })?;
         201  +
        builder.path = builder.path.or(Some(String::new()));
         202  +
        builder.server_certificate_name = builder.server_certificate_name.or(Some(String::new()));
         203  +
        builder.server_certificate_id = builder.server_certificate_id.or(Some(String::new()));
         204  +
        builder.arn = builder.arn.or(Some(String::new()));
  201    205   
        builder
  202    206   
            .build()
  203    207   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  204    208   
    }
  205    209   
}
         210  +
impl ServerCertificateMetadata {
         211  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         212  +
    pub fn deserialize_with_response(
         213  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         214  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         215  +
        _status: u16,
         216  +
        _body: &[u8],
         217  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         218  +
        Self::deserialize(deserializer)
         219  +
    }
         220  +
}
  206    221   
impl ServerCertificateMetadata {
  207    222   
    /// Creates a new builder-style object to manufacture [`ServerCertificateMetadata`](crate::types::ServerCertificateMetadata).
  208    223   
    pub fn builder() -> crate::types::builders::ServerCertificateMetadataBuilder {
  209    224   
        crate::types::builders::ServerCertificateMetadataBuilder::default()
  210    225   
    }
  211    226   
}
  212    227   
  213    228   
/// A builder for [`ServerCertificateMetadata`](crate::types::ServerCertificateMetadata).
  214    229   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  215    230   
#[non_exhaustive]

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

@@ -48,48 +168,168 @@
   68     68   
}
   69     69   
static SERVICELASTACCESSED_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   70     70   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#ServiceLastAccessed", "com.amazonaws.iam", "ServiceLastAccessed");
   71     71   
static SERVICELASTACCESSED_MEMBER_SERVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.iam#ServiceLastAccessed$ServiceName",
   74     74   
        "com.amazonaws.iam",
   75     75   
        "ServiceLastAccessed",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "service_name",
          78  +
    "ServiceName",
   79     79   
    0,
   80     80   
);
   81     81   
static SERVICELASTACCESSED_MEMBER_LAST_AUTHENTICATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.iam#ServiceLastAccessed$LastAuthenticated",
   84     84   
        "com.amazonaws.iam",
   85     85   
        "ServiceLastAccessed",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Timestamp,
   88         -
    "last_authenticated",
          88  +
    "LastAuthenticated",
   89     89   
    1,
   90     90   
);
   91     91   
static SERVICELASTACCESSED_MEMBER_SERVICE_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.iam#ServiceLastAccessed$ServiceNamespace",
   94     94   
        "com.amazonaws.iam",
   95     95   
        "ServiceLastAccessed",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "service_namespace",
          98  +
    "ServiceNamespace",
   99     99   
    2,
  100    100   
);
  101    101   
static SERVICELASTACCESSED_MEMBER_LAST_AUTHENTICATED_ENTITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.iam#ServiceLastAccessed$LastAuthenticatedEntity",
  104    104   
        "com.amazonaws.iam",
  105    105   
        "ServiceLastAccessed",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "last_authenticated_entity",
         108  +
    "LastAuthenticatedEntity",
  109    109   
    3,
  110    110   
);
  111    111   
static SERVICELASTACCESSED_MEMBER_LAST_AUTHENTICATED_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.iam#ServiceLastAccessed$LastAuthenticatedRegion",
  114    114   
        "com.amazonaws.iam",
  115    115   
        "ServiceLastAccessed",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::String,
  118         -
    "last_authenticated_region",
         118  +
    "LastAuthenticatedRegion",
  119    119   
    4,
  120    120   
);
  121    121   
static SERVICELASTACCESSED_MEMBER_TOTAL_AUTHENTICATED_ENTITIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.iam#ServiceLastAccessed$TotalAuthenticatedEntities",
  124    124   
        "com.amazonaws.iam",
  125    125   
        "ServiceLastAccessed",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::Integer,
  128         -
    "total_authenticated_entities",
         128  +
    "TotalAuthenticatedEntities",
  129    129   
    5,
  130    130   
);
  131    131   
static SERVICELASTACCESSED_MEMBER_TRACKED_ACTIONS_LAST_ACCESSED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static(
  133    133   
        "com.amazonaws.iam#ServiceLastAccessed$TrackedActionsLastAccessed",
  134    134   
        "com.amazonaws.iam",
  135    135   
        "ServiceLastAccessed",
  136    136   
    ),
  137    137   
    ::aws_smithy_schema::ShapeType::List,
  138         -
    "tracked_actions_last_accessed",
         138  +
    "TrackedActionsLastAccessed",
  139    139   
    6,
  140    140   
);
  141    141   
static SERVICELASTACCESSED_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  142    142   
    SERVICELASTACCESSED_SCHEMA_ID,
  143    143   
    ::aws_smithy_schema::ShapeType::Structure,
  144    144   
    &[
  145    145   
        &SERVICELASTACCESSED_MEMBER_SERVICE_NAME,
  146    146   
        &SERVICELASTACCESSED_MEMBER_LAST_AUTHENTICATED,
  147    147   
        &SERVICELASTACCESSED_MEMBER_SERVICE_NAMESPACE,
  148    148   
        &SERVICELASTACCESSED_MEMBER_LAST_AUTHENTICATED_ENTITY,
@@ -170,170 +283,293 @@
  190    190   
                    }
  191    191   
                    Ok(())
  192    192   
                },
  193    193   
            )?;
  194    194   
        }
  195    195   
        Ok(())
  196    196   
    }
  197    197   
}
  198    198   
impl ServiceLastAccessed {
  199    199   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  200         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  201         -
        deserializer: &mut D,
         200  +
    pub fn deserialize(
         201  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  202    202   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  203    203   
        #[allow(unused_variables, unused_mut)]
  204    204   
        let mut builder = Self::builder();
  205    205   
        #[allow(
  206    206   
            unused_variables,
  207    207   
            unreachable_code,
  208    208   
            clippy::single_match,
  209    209   
            clippy::match_single_binding,
  210    210   
            clippy::diverging_sub_expression
  211    211   
        )]
  212         -
        deserializer.read_struct(&SERVICELASTACCESSED_SCHEMA, (), |_, member, deser| {
         212  +
        deserializer.read_struct(&SERVICELASTACCESSED_SCHEMA, &mut |member, deser| {
  213    213   
            match member.member_index() {
  214    214   
                Some(0) => {
  215    215   
                    builder.service_name = Some(deser.read_string(member)?);
  216    216   
                }
  217    217   
                Some(1) => {
  218    218   
                    builder.last_authenticated = Some(deser.read_timestamp(member)?);
  219    219   
                }
  220    220   
                Some(2) => {
  221    221   
                    builder.service_namespace = Some(deser.read_string(member)?);
  222    222   
                }
  223    223   
                Some(3) => {
  224    224   
                    builder.last_authenticated_entity = Some(deser.read_string(member)?);
  225    225   
                }
  226    226   
                Some(4) => {
  227    227   
                    builder.last_authenticated_region = Some(deser.read_string(member)?);
  228    228   
                }
  229    229   
                Some(5) => {
  230    230   
                    builder.total_authenticated_entities = Some(deser.read_integer(member)?);
  231    231   
                }
  232    232   
                Some(6) => {
  233    233   
                    builder.tracked_actions_last_accessed = Some({
  234         -
                        let container = if let Some(cap) = deser.container_size() {
  235         -
                            Vec::with_capacity(cap)
  236         -
                        } else {
  237         -
                            Vec::new()
  238         -
                        };
  239         -
                        deser.read_list(member, container, |mut list, deser| {
  240         -
                            list.push(crate::types::TrackedActionLastAccessed::deserialize(deser)?);
  241         -
                            Ok(list)
  242         -
                        })?
         234  +
                        let mut container = Vec::new();
         235  +
                        deser.read_list(member, &mut |deser| {
         236  +
                            container.push(crate::types::TrackedActionLastAccessed::deserialize(deser)?);
         237  +
                            Ok(())
         238  +
                        })?;
         239  +
                        container
  243    240   
                    });
  244    241   
                }
  245    242   
                _ => {}
  246    243   
            }
  247    244   
            Ok(())
  248    245   
        })?;
         246  +
        builder.service_name = builder.service_name.or(Some(String::new()));
         247  +
        builder.service_namespace = builder.service_namespace.or(Some(String::new()));
  249    248   
        builder
  250    249   
            .build()
  251    250   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  252    251   
    }
  253    252   
}
         253  +
impl ServiceLastAccessed {
         254  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         255  +
    pub fn deserialize_with_response(
         256  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         257  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         258  +
        _status: u16,
         259  +
        _body: &[u8],
         260  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         261  +
        Self::deserialize(deserializer)
         262  +
    }
         263  +
}
  254    264   
impl ServiceLastAccessed {
  255    265   
    /// Creates a new builder-style object to manufacture [`ServiceLastAccessed`](crate::types::ServiceLastAccessed).
  256    266   
    pub fn builder() -> crate::types::builders::ServiceLastAccessedBuilder {
  257    267   
        crate::types::builders::ServiceLastAccessedBuilder::default()
  258    268   
    }
  259    269   
}
  260    270   
  261    271   
/// A builder for [`ServiceLastAccessed`](crate::types::ServiceLastAccessed).
  262    272   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  263    273   
#[non_exhaustive]

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

@@ -73,73 +223,223 @@
   93     93   
    "com.amazonaws.iam",
   94     94   
    "ServiceSpecificCredential",
   95     95   
);
   96     96   
static SERVICESPECIFICCREDENTIAL_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.iam#ServiceSpecificCredential$CreateDate",
   99     99   
        "com.amazonaws.iam",
  100    100   
        "ServiceSpecificCredential",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::Timestamp,
  103         -
    "create_date",
         103  +
    "CreateDate",
  104    104   
    0,
  105    105   
);
  106    106   
static SERVICESPECIFICCREDENTIAL_MEMBER_EXPIRATION_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.iam#ServiceSpecificCredential$ExpirationDate",
  109    109   
        "com.amazonaws.iam",
  110    110   
        "ServiceSpecificCredential",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::Timestamp,
  113         -
    "expiration_date",
         113  +
    "ExpirationDate",
  114    114   
    1,
  115    115   
);
  116    116   
static SERVICESPECIFICCREDENTIAL_MEMBER_SERVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static(
  118    118   
        "com.amazonaws.iam#ServiceSpecificCredential$ServiceName",
  119    119   
        "com.amazonaws.iam",
  120    120   
        "ServiceSpecificCredential",
  121    121   
    ),
  122    122   
    ::aws_smithy_schema::ShapeType::String,
  123         -
    "service_name",
         123  +
    "ServiceName",
  124    124   
    2,
  125    125   
);
  126    126   
static SERVICESPECIFICCREDENTIAL_MEMBER_SERVICE_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static(
  128    128   
        "com.amazonaws.iam#ServiceSpecificCredential$ServiceUserName",
  129    129   
        "com.amazonaws.iam",
  130    130   
        "ServiceSpecificCredential",
  131    131   
    ),
  132    132   
    ::aws_smithy_schema::ShapeType::String,
  133         -
    "service_user_name",
         133  +
    "ServiceUserName",
  134    134   
    3,
  135    135   
);
  136    136   
static SERVICESPECIFICCREDENTIAL_MEMBER_SERVICE_PASSWORD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static(
  138    138   
        "com.amazonaws.iam#ServiceSpecificCredential$ServicePassword",
  139    139   
        "com.amazonaws.iam",
  140    140   
        "ServiceSpecificCredential",
  141    141   
    ),
  142    142   
    ::aws_smithy_schema::ShapeType::String,
  143         -
    "service_password",
         143  +
    "ServicePassword",
  144    144   
    4,
  145    145   
);
  146    146   
static SERVICESPECIFICCREDENTIAL_MEMBER_SERVICE_CREDENTIAL_ALIAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static(
  148    148   
        "com.amazonaws.iam#ServiceSpecificCredential$ServiceCredentialAlias",
  149    149   
        "com.amazonaws.iam",
  150    150   
        "ServiceSpecificCredential",
  151    151   
    ),
  152    152   
    ::aws_smithy_schema::ShapeType::String,
  153         -
    "service_credential_alias",
         153  +
    "ServiceCredentialAlias",
  154    154   
    5,
  155    155   
);
  156    156   
static SERVICESPECIFICCREDENTIAL_MEMBER_SERVICE_CREDENTIAL_SECRET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.iam#ServiceSpecificCredential$ServiceCredentialSecret",
  159    159   
        "com.amazonaws.iam",
  160    160   
        "ServiceSpecificCredential",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163         -
    "service_credential_secret",
         163  +
    "ServiceCredentialSecret",
  164    164   
    6,
  165    165   
);
  166    166   
static SERVICESPECIFICCREDENTIAL_MEMBER_SERVICE_SPECIFIC_CREDENTIAL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static(
  168    168   
        "com.amazonaws.iam#ServiceSpecificCredential$ServiceSpecificCredentialId",
  169    169   
        "com.amazonaws.iam",
  170    170   
        "ServiceSpecificCredential",
  171    171   
    ),
  172    172   
    ::aws_smithy_schema::ShapeType::String,
  173         -
    "service_specific_credential_id",
         173  +
    "ServiceSpecificCredentialId",
  174    174   
    7,
  175    175   
);
  176    176   
static SERVICESPECIFICCREDENTIAL_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  177    177   
    ::aws_smithy_schema::ShapeId::from_static(
  178    178   
        "com.amazonaws.iam#ServiceSpecificCredential$UserName",
  179    179   
        "com.amazonaws.iam",
  180    180   
        "ServiceSpecificCredential",
  181    181   
    ),
  182    182   
    ::aws_smithy_schema::ShapeType::String,
  183         -
    "user_name",
         183  +
    "UserName",
  184    184   
    8,
  185    185   
);
  186    186   
static SERVICESPECIFICCREDENTIAL_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  187    187   
    ::aws_smithy_schema::ShapeId::from_static(
  188    188   
        "com.amazonaws.iam#ServiceSpecificCredential$Status",
  189    189   
        "com.amazonaws.iam",
  190    190   
        "ServiceSpecificCredential",
  191    191   
    ),
  192    192   
    ::aws_smithy_schema::ShapeType::String,
  193         -
    "status",
         193  +
    "Status",
  194    194   
    9,
  195    195   
);
  196    196   
static SERVICESPECIFICCREDENTIAL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  197    197   
    SERVICESPECIFICCREDENTIAL_SCHEMA_ID,
  198    198   
    ::aws_smithy_schema::ShapeType::Structure,
  199    199   
    &[
  200    200   
        &SERVICESPECIFICCREDENTIAL_MEMBER_CREATE_DATE,
  201    201   
        &SERVICESPECIFICCREDENTIAL_MEMBER_EXPIRATION_DATE,
  202    202   
        &SERVICESPECIFICCREDENTIAL_MEMBER_SERVICE_NAME,
  203    203   
        &SERVICESPECIFICCREDENTIAL_MEMBER_SERVICE_USER_NAME,
@@ -234,234 +346,361 @@
  254    254   
        }
  255    255   
        {
  256    256   
            let val = &self.status;
  257    257   
            ser.write_string(&SERVICESPECIFICCREDENTIAL_MEMBER_STATUS, val.as_str())?;
  258    258   
        }
  259    259   
        Ok(())
  260    260   
    }
  261    261   
}
  262    262   
impl ServiceSpecificCredential {
  263    263   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  264         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  265         -
        deserializer: &mut D,
         264  +
    pub fn deserialize(
         265  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  266    266   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  267    267   
        #[allow(unused_variables, unused_mut)]
  268    268   
        let mut builder = Self::builder();
  269    269   
        #[allow(
  270    270   
            unused_variables,
  271    271   
            unreachable_code,
  272    272   
            clippy::single_match,
  273    273   
            clippy::match_single_binding,
  274    274   
            clippy::diverging_sub_expression
  275    275   
        )]
  276         -
        deserializer.read_struct(&SERVICESPECIFICCREDENTIAL_SCHEMA, (), |_, member, deser| {
         276  +
        deserializer.read_struct(&SERVICESPECIFICCREDENTIAL_SCHEMA, &mut |member, deser| {
  277    277   
            match member.member_index() {
  278    278   
                Some(0) => {
  279    279   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  280    280   
                }
  281    281   
                Some(1) => {
  282    282   
                    builder.expiration_date = Some(deser.read_timestamp(member)?);
  283    283   
                }
  284    284   
                Some(2) => {
  285    285   
                    builder.service_name = Some(deser.read_string(member)?);
  286    286   
                }
  287    287   
                Some(3) => {
  288    288   
                    builder.service_user_name = Some(deser.read_string(member)?);
  289    289   
                }
  290    290   
                Some(4) => {
  291    291   
                    builder.service_password = Some(deser.read_string(member)?);
  292    292   
                }
  293    293   
                Some(5) => {
  294    294   
                    builder.service_credential_alias = Some(deser.read_string(member)?);
  295    295   
                }
  296    296   
                Some(6) => {
  297    297   
                    builder.service_credential_secret = Some(deser.read_string(member)?);
  298    298   
                }
  299    299   
                Some(7) => {
  300    300   
                    builder.service_specific_credential_id = Some(deser.read_string(member)?);
  301    301   
                }
  302    302   
                Some(8) => {
  303    303   
                    builder.user_name = Some(deser.read_string(member)?);
  304    304   
                }
  305    305   
                Some(9) => {
  306    306   
                    builder.status = Some(crate::types::StatusType::from(deser.read_string(member)?.as_str()));
  307    307   
                }
  308    308   
                _ => {}
  309    309   
            }
  310    310   
            Ok(())
  311    311   
        })?;
         312  +
        builder.create_date = builder.create_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
         313  +
        builder.service_name = builder.service_name.or(Some(String::new()));
         314  +
        builder.service_specific_credential_id = builder.service_specific_credential_id.or(Some(String::new()));
         315  +
        builder.user_name = builder.user_name.or(Some(String::new()));
  312    316   
        builder
  313    317   
            .build()
  314    318   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  315    319   
    }
  316    320   
}
         321  +
impl ServiceSpecificCredential {
         322  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         323  +
    pub fn deserialize_with_response(
         324  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         325  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         326  +
        _status: u16,
         327  +
        _body: &[u8],
         328  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         329  +
        Self::deserialize(deserializer)
         330  +
    }
         331  +
}
  317    332   
impl ServiceSpecificCredential {
  318    333   
    /// Creates a new builder-style object to manufacture [`ServiceSpecificCredential`](crate::types::ServiceSpecificCredential).
  319    334   
    pub fn builder() -> crate::types::builders::ServiceSpecificCredentialBuilder {
  320    335   
        crate::types::builders::ServiceSpecificCredentialBuilder::default()
  321    336   
    }
  322    337   
}
  323    338   
  324    339   
/// A builder for [`ServiceSpecificCredential`](crate::types::ServiceSpecificCredential).
  325    340   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  326    341   
#[non_exhaustive]

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

@@ -44,44 +174,174 @@
   64     64   
    "com.amazonaws.iam",
   65     65   
    "ServiceSpecificCredentialMetadata",
   66     66   
);
   67     67   
static SERVICESPECIFICCREDENTIALMETADATA_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.iam#ServiceSpecificCredentialMetadata$UserName",
   70     70   
        "com.amazonaws.iam",
   71     71   
        "ServiceSpecificCredentialMetadata",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::String,
   74         -
    "user_name",
          74  +
    "UserName",
   75     75   
    0,
   76     76   
);
   77     77   
static SERVICESPECIFICCREDENTIALMETADATA_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.iam#ServiceSpecificCredentialMetadata$Status",
   80     80   
        "com.amazonaws.iam",
   81     81   
        "ServiceSpecificCredentialMetadata",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "status",
          84  +
    "Status",
   85     85   
    1,
   86     86   
);
   87     87   
static SERVICESPECIFICCREDENTIALMETADATA_MEMBER_SERVICE_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.iam#ServiceSpecificCredentialMetadata$ServiceUserName",
   90     90   
        "com.amazonaws.iam",
   91     91   
        "ServiceSpecificCredentialMetadata",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "service_user_name",
          94  +
    "ServiceUserName",
   95     95   
    2,
   96     96   
);
   97     97   
static SERVICESPECIFICCREDENTIALMETADATA_MEMBER_SERVICE_CREDENTIAL_ALIAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.iam#ServiceSpecificCredentialMetadata$ServiceCredentialAlias",
  100    100   
        "com.amazonaws.iam",
  101    101   
        "ServiceSpecificCredentialMetadata",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::String,
  104         -
    "service_credential_alias",
         104  +
    "ServiceCredentialAlias",
  105    105   
    3,
  106    106   
);
  107    107   
static SERVICESPECIFICCREDENTIALMETADATA_MEMBER_CREATE_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.iam#ServiceSpecificCredentialMetadata$CreateDate",
  110    110   
        "com.amazonaws.iam",
  111    111   
        "ServiceSpecificCredentialMetadata",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::Timestamp,
  114         -
    "create_date",
         114  +
    "CreateDate",
  115    115   
    4,
  116    116   
);
  117    117   
static SERVICESPECIFICCREDENTIALMETADATA_MEMBER_EXPIRATION_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.iam#ServiceSpecificCredentialMetadata$ExpirationDate",
  120    120   
        "com.amazonaws.iam",
  121    121   
        "ServiceSpecificCredentialMetadata",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::Timestamp,
  124         -
    "expiration_date",
         124  +
    "ExpirationDate",
  125    125   
    5,
  126    126   
);
  127    127   
static SERVICESPECIFICCREDENTIALMETADATA_MEMBER_SERVICE_SPECIFIC_CREDENTIAL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.iam#ServiceSpecificCredentialMetadata$ServiceSpecificCredentialId",
  130    130   
        "com.amazonaws.iam",
  131    131   
        "ServiceSpecificCredentialMetadata",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::String,
  134         -
    "service_specific_credential_id",
         134  +
    "ServiceSpecificCredentialId",
  135    135   
    6,
  136    136   
);
  137    137   
static SERVICESPECIFICCREDENTIALMETADATA_MEMBER_SERVICE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.iam#ServiceSpecificCredentialMetadata$ServiceName",
  140    140   
        "com.amazonaws.iam",
  141    141   
        "ServiceSpecificCredentialMetadata",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::String,
  144         -
    "service_name",
         144  +
    "ServiceName",
  145    145   
    7,
  146    146   
);
  147    147   
static SERVICESPECIFICCREDENTIALMETADATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  148    148   
    SERVICESPECIFICCREDENTIALMETADATA_SCHEMA_ID,
  149    149   
    ::aws_smithy_schema::ShapeType::Structure,
  150    150   
    &[
  151    151   
        &SERVICESPECIFICCREDENTIALMETADATA_MEMBER_USER_NAME,
  152    152   
        &SERVICESPECIFICCREDENTIALMETADATA_MEMBER_STATUS,
  153    153   
        &SERVICESPECIFICCREDENTIALMETADATA_MEMBER_SERVICE_USER_NAME,
  154    154   
        &SERVICESPECIFICCREDENTIALMETADATA_MEMBER_SERVICE_CREDENTIAL_ALIAS,
@@ -176,176 +282,297 @@
  196    196   
        }
  197    197   
        {
  198    198   
            let val = &self.service_name;
  199    199   
            ser.write_string(&SERVICESPECIFICCREDENTIALMETADATA_MEMBER_SERVICE_NAME, val)?;
  200    200   
        }
  201    201   
        Ok(())
  202    202   
    }
  203    203   
}
  204    204   
impl ServiceSpecificCredentialMetadata {
  205    205   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  206         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  207         -
        deserializer: &mut D,
         206  +
    pub fn deserialize(
         207  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  208    208   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  209    209   
        #[allow(unused_variables, unused_mut)]
  210    210   
        let mut builder = Self::builder();
  211    211   
        #[allow(
  212    212   
            unused_variables,
  213    213   
            unreachable_code,
  214    214   
            clippy::single_match,
  215    215   
            clippy::match_single_binding,
  216    216   
            clippy::diverging_sub_expression
  217    217   
        )]
  218         -
        deserializer.read_struct(&SERVICESPECIFICCREDENTIALMETADATA_SCHEMA, (), |_, member, deser| {
         218  +
        deserializer.read_struct(&SERVICESPECIFICCREDENTIALMETADATA_SCHEMA, &mut |member, deser| {
  219    219   
            match member.member_index() {
  220    220   
                Some(0) => {
  221    221   
                    builder.user_name = Some(deser.read_string(member)?);
  222    222   
                }
  223    223   
                Some(1) => {
  224    224   
                    builder.status = Some(crate::types::StatusType::from(deser.read_string(member)?.as_str()));
  225    225   
                }
  226    226   
                Some(2) => {
  227    227   
                    builder.service_user_name = Some(deser.read_string(member)?);
  228    228   
                }
  229    229   
                Some(3) => {
  230    230   
                    builder.service_credential_alias = Some(deser.read_string(member)?);
  231    231   
                }
  232    232   
                Some(4) => {
  233    233   
                    builder.create_date = Some(deser.read_timestamp(member)?);
  234    234   
                }
  235    235   
                Some(5) => {
  236    236   
                    builder.expiration_date = Some(deser.read_timestamp(member)?);
  237    237   
                }
  238    238   
                Some(6) => {
  239    239   
                    builder.service_specific_credential_id = Some(deser.read_string(member)?);
  240    240   
                }
  241    241   
                Some(7) => {
  242    242   
                    builder.service_name = Some(deser.read_string(member)?);
  243    243   
                }
  244    244   
                _ => {}
  245    245   
            }
  246    246   
            Ok(())
  247    247   
        })?;
         248  +
        builder.user_name = builder.user_name.or(Some(String::new()));
         249  +
        builder.create_date = builder.create_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
         250  +
        builder.service_specific_credential_id = builder.service_specific_credential_id.or(Some(String::new()));
         251  +
        builder.service_name = builder.service_name.or(Some(String::new()));
  248    252   
        builder
  249    253   
            .build()
  250    254   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  251    255   
    }
  252    256   
}
         257  +
impl ServiceSpecificCredentialMetadata {
         258  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         259  +
    pub fn deserialize_with_response(
         260  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         261  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         262  +
        _status: u16,
         263  +
        _body: &[u8],
         264  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         265  +
        Self::deserialize(deserializer)
         266  +
    }
         267  +
}
  253    268   
impl ServiceSpecificCredentialMetadata {
  254    269   
    /// Creates a new builder-style object to manufacture [`ServiceSpecificCredentialMetadata`](crate::types::ServiceSpecificCredentialMetadata).
  255    270   
    pub fn builder() -> crate::types::builders::ServiceSpecificCredentialMetadataBuilder {
  256    271   
        crate::types::builders::ServiceSpecificCredentialMetadataBuilder::default()
  257    272   
    }
  258    273   
}
  259    274   
  260    275   
/// A builder for [`ServiceSpecificCredentialMetadata`](crate::types::ServiceSpecificCredentialMetadata).
  261    276   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  262    277   
#[non_exhaustive]

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

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

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

@@ -26,26 +209,224 @@
   46     46   
    /// <p>The date and time, in <a href="http://www.iso.org/iso/iso8601">ISO 8601 date-time format</a>, when the SSH public key was uploaded.</p>
   47     47   
    pub fn upload_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   48     48   
        self.upload_date.as_ref()
   49     49   
    }
   50     50   
}
   51     51   
static SSHPUBLICKEY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   52     52   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#SSHPublicKey", "com.amazonaws.iam", "SSHPublicKey");
   53     53   
static SSHPUBLICKEY_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#SSHPublicKey$UserName", "com.amazonaws.iam", "SSHPublicKey"),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "user_name",
          56  +
    "UserName",
   57     57   
    0,
   58     58   
);
   59     59   
static SSHPUBLICKEY_MEMBER_SSH_PUBLIC_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#SSHPublicKey$SSHPublicKeyId", "com.amazonaws.iam", "SSHPublicKey"),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "ssh_public_key_id",
          62  +
    "SSHPublicKeyId",
   63     63   
    1,
   64     64   
);
   65     65   
static SSHPUBLICKEY_MEMBER_FINGERPRINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#SSHPublicKey$Fingerprint", "com.amazonaws.iam", "SSHPublicKey"),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "fingerprint",
          68  +
    "Fingerprint",
   69     69   
    2,
   70     70   
);
   71     71   
static SSHPUBLICKEY_MEMBER_SSH_PUBLIC_KEY_BODY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#SSHPublicKey$SSHPublicKeyBody", "com.amazonaws.iam", "SSHPublicKey"),
   73     73   
    ::aws_smithy_schema::ShapeType::String,
   74         -
    "ssh_public_key_body",
          74  +
    "SSHPublicKeyBody",
   75     75   
    3,
   76     76   
);
   77     77   
static SSHPUBLICKEY_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#SSHPublicKey$Status", "com.amazonaws.iam", "SSHPublicKey"),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "status",
          80  +
    "Status",
   81     81   
    4,
   82     82   
);
   83     83   
static SSHPUBLICKEY_MEMBER_UPLOAD_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam#SSHPublicKey$UploadDate", "com.amazonaws.iam", "SSHPublicKey"),
   85     85   
    ::aws_smithy_schema::ShapeType::Timestamp,
   86         -
    "upload_date",
          86  +
    "UploadDate",
   87     87   
    5,
   88     88   
);
   89     89   
static SSHPUBLICKEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   90     90   
    SSHPUBLICKEY_SCHEMA_ID,
   91     91   
    ::aws_smithy_schema::ShapeType::Structure,
   92     92   
    &[
   93     93   
        &SSHPUBLICKEY_MEMBER_USER_NAME,
   94     94   
        &SSHPUBLICKEY_MEMBER_SSH_PUBLIC_KEY_ID,
   95     95   
        &SSHPUBLICKEY_MEMBER_FINGERPRINT,
   96     96   
        &SSHPUBLICKEY_MEMBER_SSH_PUBLIC_KEY_BODY,
   97     97   
        &SSHPUBLICKEY_MEMBER_STATUS,
   98     98   
        &SSHPUBLICKEY_MEMBER_UPLOAD_DATE,
   99     99   
    ],
  100    100   
);
  101    101   
impl SshPublicKey {
  102    102   
    /// The schema for this shape.
  103    103   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SSHPUBLICKEY_SCHEMA;
  104    104   
}
  105    105   
impl ::aws_smithy_schema::serde::SerializableStruct for SshPublicKey {
  106    106   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  107    107   
    fn serialize_members(
  108    108   
        &self,
  109    109   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  110    110   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  111    111   
        {
  112    112   
            let val = &self.user_name;
  113    113   
            ser.write_string(&SSHPUBLICKEY_MEMBER_USER_NAME, val)?;
  114    114   
        }
  115    115   
        {
  116    116   
            let val = &self.ssh_public_key_id;
  117    117   
            ser.write_string(&SSHPUBLICKEY_MEMBER_SSH_PUBLIC_KEY_ID, val)?;
  118    118   
        }
  119    119   
        {
  120    120   
            let val = &self.fingerprint;
  121    121   
            ser.write_string(&SSHPUBLICKEY_MEMBER_FINGERPRINT, val)?;
  122    122   
        }
  123    123   
        {
  124    124   
            let val = &self.ssh_public_key_body;
  125    125   
            ser.write_string(&SSHPUBLICKEY_MEMBER_SSH_PUBLIC_KEY_BODY, val)?;
  126    126   
        }
  127    127   
        {
  128    128   
            let val = &self.status;
  129    129   
            ser.write_string(&SSHPUBLICKEY_MEMBER_STATUS, val.as_str())?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.upload_date {
  132    132   
            ser.write_timestamp(&SSHPUBLICKEY_MEMBER_UPLOAD_DATE, val)?;
  133    133   
        }
  134    134   
        Ok(())
  135    135   
    }
  136    136   
}
  137    137   
impl SshPublicKey {
  138    138   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  139         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  140         -
        deserializer: &mut D,
         139  +
    pub fn deserialize(
         140  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  141    141   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  142    142   
        #[allow(unused_variables, unused_mut)]
  143    143   
        let mut builder = Self::builder();
  144    144   
        #[allow(
  145    145   
            unused_variables,
  146    146   
            unreachable_code,
  147    147   
            clippy::single_match,
  148    148   
            clippy::match_single_binding,
  149    149   
            clippy::diverging_sub_expression
  150    150   
        )]
  151         -
        deserializer.read_struct(&SSHPUBLICKEY_SCHEMA, (), |_, member, deser| {
         151  +
        deserializer.read_struct(&SSHPUBLICKEY_SCHEMA, &mut |member, deser| {
  152    152   
            match member.member_index() {
  153    153   
                Some(0) => {
  154    154   
                    builder.user_name = Some(deser.read_string(member)?);
  155    155   
                }
  156    156   
                Some(1) => {
  157    157   
                    builder.ssh_public_key_id = Some(deser.read_string(member)?);
  158    158   
                }
  159    159   
                Some(2) => {
  160    160   
                    builder.fingerprint = Some(deser.read_string(member)?);
  161    161   
                }
  162    162   
                Some(3) => {
  163    163   
                    builder.ssh_public_key_body = Some(deser.read_string(member)?);
  164    164   
                }
  165    165   
                Some(4) => {
  166    166   
                    builder.status = Some(crate::types::StatusType::from(deser.read_string(member)?.as_str()));
  167    167   
                }
  168    168   
                Some(5) => {
  169    169   
                    builder.upload_date = Some(deser.read_timestamp(member)?);
  170    170   
                }
  171    171   
                _ => {}
  172    172   
            }
  173    173   
            Ok(())
  174    174   
        })?;
         175  +
        builder.user_name = builder.user_name.or(Some(String::new()));
         176  +
        builder.ssh_public_key_id = builder.ssh_public_key_id.or(Some(String::new()));
         177  +
        builder.fingerprint = builder.fingerprint.or(Some(String::new()));
         178  +
        builder.ssh_public_key_body = builder.ssh_public_key_body.or(Some(String::new()));
  175    179   
        builder
  176    180   
            .build()
  177    181   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  178    182   
    }
  179    183   
}
         184  +
impl SshPublicKey {
         185  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         186  +
    pub fn deserialize_with_response(
         187  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         188  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         189  +
        _status: u16,
         190  +
        _body: &[u8],
         191  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         192  +
        Self::deserialize(deserializer)
         193  +
    }
         194  +
}
  180    195   
impl SshPublicKey {
  181    196   
    /// Creates a new builder-style object to manufacture [`SshPublicKey`](crate::types::SshPublicKey).
  182    197   
    pub fn builder() -> crate::types::builders::SshPublicKeyBuilder {
  183    198   
        crate::types::builders::SshPublicKeyBuilder::default()
  184    199   
    }
  185    200   
}
  186    201   
  187    202   
/// A builder for [`SshPublicKey`](crate::types::SshPublicKey).
  188    203   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  189    204   
#[non_exhaustive]