AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_account_usage.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_alias_configuration.rs

@@ -25,25 +221,232 @@
   45     45   
}
   46     46   
static ALIASCONFIGURATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#AliasConfiguration", "com.amazonaws.lambda", "AliasConfiguration");
   48     48   
static ALIASCONFIGURATION_MEMBER_ALIAS_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.lambda#AliasConfiguration$AliasArn",
   51     51   
        "com.amazonaws.lambda",
   52     52   
        "AliasConfiguration",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::String,
   55         -
    "alias_arn",
          55  +
    "AliasArn",
   56     56   
    0,
   57     57   
);
   58     58   
static ALIASCONFIGURATION_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.lambda#AliasConfiguration$Name",
   61     61   
        "com.amazonaws.lambda",
   62     62   
        "AliasConfiguration",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "name",
          65  +
    "Name",
   66     66   
    1,
   67     67   
);
   68     68   
static ALIASCONFIGURATION_MEMBER_FUNCTION_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.lambda#AliasConfiguration$FunctionVersion",
   71     71   
        "com.amazonaws.lambda",
   72     72   
        "AliasConfiguration",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "function_version",
          75  +
    "FunctionVersion",
   76     76   
    2,
   77     77   
);
   78     78   
static ALIASCONFIGURATION_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.lambda#AliasConfiguration$Description",
   81     81   
        "com.amazonaws.lambda",
   82     82   
        "AliasConfiguration",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "description",
          85  +
    "Description",
   86     86   
    3,
   87     87   
);
   88     88   
static ALIASCONFIGURATION_MEMBER_ROUTING_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.lambda#AliasConfiguration$RoutingConfig",
   91     91   
        "com.amazonaws.lambda",
   92     92   
        "AliasConfiguration",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::Structure,
   95         -
    "routing_config",
          95  +
    "RoutingConfig",
   96     96   
    4,
   97     97   
);
   98     98   
static ALIASCONFIGURATION_MEMBER_REVISION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.lambda#AliasConfiguration$RevisionId",
  101    101   
        "com.amazonaws.lambda",
  102    102   
        "AliasConfiguration",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "revision_id",
         105  +
    "RevisionId",
  106    106   
    5,
  107    107   
);
  108    108   
static ALIASCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  109    109   
    ALIASCONFIGURATION_SCHEMA_ID,
  110    110   
    ::aws_smithy_schema::ShapeType::Structure,
  111    111   
    &[
  112    112   
        &ALIASCONFIGURATION_MEMBER_ALIAS_ARN,
  113    113   
        &ALIASCONFIGURATION_MEMBER_NAME,
  114    114   
        &ALIASCONFIGURATION_MEMBER_FUNCTION_VERSION,
  115    115   
        &ALIASCONFIGURATION_MEMBER_DESCRIPTION,
  116    116   
        &ALIASCONFIGURATION_MEMBER_ROUTING_CONFIG,
  117    117   
        &ALIASCONFIGURATION_MEMBER_REVISION_ID,
  118    118   
    ],
  119    119   
);
  120    120   
impl AliasConfiguration {
  121    121   
    /// The schema for this shape.
  122    122   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ALIASCONFIGURATION_SCHEMA;
  123    123   
}
  124    124   
impl ::aws_smithy_schema::serde::SerializableStruct for AliasConfiguration {
  125    125   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  126    126   
    fn serialize_members(
  127    127   
        &self,
  128    128   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  129    129   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  130    130   
        if let Some(ref val) = self.alias_arn {
  131    131   
            ser.write_string(&ALIASCONFIGURATION_MEMBER_ALIAS_ARN, val)?;
  132    132   
        }
  133    133   
        if let Some(ref val) = self.name {
  134    134   
            ser.write_string(&ALIASCONFIGURATION_MEMBER_NAME, val)?;
  135    135   
        }
  136    136   
        if let Some(ref val) = self.function_version {
  137    137   
            ser.write_string(&ALIASCONFIGURATION_MEMBER_FUNCTION_VERSION, val)?;
  138    138   
        }
  139    139   
        if let Some(ref val) = self.description {
  140    140   
            ser.write_string(&ALIASCONFIGURATION_MEMBER_DESCRIPTION, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.routing_config {
  143    143   
            ser.write_struct(&ALIASCONFIGURATION_MEMBER_ROUTING_CONFIG, val)?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.revision_id {
  146    146   
            ser.write_string(&ALIASCONFIGURATION_MEMBER_REVISION_ID, val)?;
  147    147   
        }
  148    148   
        Ok(())
  149    149   
    }
  150    150   
}
  151    151   
impl AliasConfiguration {
  152    152   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  153         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  154         -
        deserializer: &mut D,
         153  +
    pub fn deserialize(
         154  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  155    155   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  156    156   
        #[allow(unused_variables, unused_mut)]
  157    157   
        let mut builder = Self::builder();
  158    158   
        #[allow(
  159    159   
            unused_variables,
  160    160   
            unreachable_code,
  161    161   
            clippy::single_match,
  162    162   
            clippy::match_single_binding,
  163    163   
            clippy::diverging_sub_expression
  164    164   
        )]
  165         -
        deserializer.read_struct(&ALIASCONFIGURATION_SCHEMA, (), |_, member, deser| {
         165  +
        deserializer.read_struct(&ALIASCONFIGURATION_SCHEMA, &mut |member, deser| {
  166    166   
            match member.member_index() {
  167    167   
                Some(0) => {
  168    168   
                    builder.alias_arn = Some(deser.read_string(member)?);
  169    169   
                }
  170    170   
                Some(1) => {
  171    171   
                    builder.name = Some(deser.read_string(member)?);
  172    172   
                }
  173    173   
                Some(2) => {
  174    174   
                    builder.function_version = Some(deser.read_string(member)?);
  175    175   
                }
  176    176   
                Some(3) => {
  177    177   
                    builder.description = Some(deser.read_string(member)?);
  178    178   
                }
  179    179   
                Some(4) => {
  180    180   
                    builder.routing_config = Some(crate::types::AliasRoutingConfiguration::deserialize(deser)?);
  181    181   
                }
  182    182   
                Some(5) => {
  183    183   
                    builder.revision_id = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                _ => {}
  186    186   
            }
  187    187   
            Ok(())
  188    188   
        })?;
  189    189   
        Ok(builder.build())
  190    190   
    }
  191    191   
}
         192  +
impl AliasConfiguration {
         193  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         194  +
    pub fn deserialize_with_response(
         195  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         196  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         197  +
        _status: u16,
         198  +
        _body: &[u8],
         199  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         200  +
        Self::deserialize(deserializer)
         201  +
    }
         202  +
}
  192    203   
impl AliasConfiguration {
  193    204   
    /// Creates a new builder-style object to manufacture [`AliasConfiguration`](crate::types::AliasConfiguration).
  194    205   
    pub fn builder() -> crate::types::builders::AliasConfigurationBuilder {
  195    206   
        crate::types::builders::AliasConfigurationBuilder::default()
  196    207   
    }
  197    208   
}
  198    209   
  199    210   
/// A builder for [`AliasConfiguration`](crate::types::AliasConfiguration).
  200    211   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  201    212   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_alias_routing_configuration.rs

@@ -1,1 +126,134 @@
   18     18   
    "com.amazonaws.lambda",
   19     19   
    "AliasRoutingConfiguration",
   20     20   
);
   21     21   
static ALIASROUTINGCONFIGURATION_MEMBER_ADDITIONAL_VERSION_WEIGHTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.lambda#AliasRoutingConfiguration$AdditionalVersionWeights",
   24     24   
        "com.amazonaws.lambda",
   25     25   
        "AliasRoutingConfiguration",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Map,
   28         -
    "additional_version_weights",
          28  +
    "AdditionalVersionWeights",
   29     29   
    0,
   30     30   
);
   31     31   
static ALIASROUTINGCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    ALIASROUTINGCONFIGURATION_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&ALIASROUTINGCONFIGURATION_MEMBER_ADDITIONAL_VERSION_WEIGHTS],
   35     35   
);
   36     36   
impl AliasRoutingConfiguration {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ALIASROUTINGCONFIGURATION_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for AliasRoutingConfiguration {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.additional_version_weights {
   47     47   
            ser.write_map(
   48     48   
                &ALIASROUTINGCONFIGURATION_MEMBER_ADDITIONAL_VERSION_WEIGHTS,
   49     49   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   50     50   
                    for (key, value) in val {
   51     51   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   52     52   
                        ser.write_double(&::aws_smithy_schema::prelude::DOUBLE, *value)?;
   53     53   
                    }
   54     54   
                    Ok(())
   55     55   
                },
   56     56   
            )?;
   57     57   
        }
   58     58   
        Ok(())
   59     59   
    }
   60     60   
}
   61     61   
impl AliasRoutingConfiguration {
   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(&ALIASROUTINGCONFIGURATION_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&ALIASROUTINGCONFIGURATION_SCHEMA, &mut |member, deser| {
   76     76   
            match member.member_index() {
   77     77   
                Some(0) => {
   78     78   
                    builder.additional_version_weights = Some({
   79         -
                        let container = if let Some(cap) = deser.container_size() {
   80         -
                            std::collections::HashMap::with_capacity(cap)
   81         -
                        } else {
   82         -
                            std::collections::HashMap::new()
   83         -
                        };
   84         -
                        deser.read_map(member, container, |mut map, key, deser| {
   85         -
                            map.insert(key, deser.read_double(member)?);
   86         -
                            Ok(map)
   87         -
                        })?
          79  +
                        let mut container = std::collections::HashMap::new();
          80  +
                        deser.read_map(member, &mut |key, deser| {
          81  +
                            container.insert(key, deser.read_double(member)?);
          82  +
                            Ok(())
          83  +
                        })?;
          84  +
                        container
   88     85   
                    });
   89     86   
                }
   90     87   
                _ => {}
   91     88   
            }
   92     89   
            Ok(())
   93     90   
        })?;
   94     91   
        Ok(builder.build())
   95     92   
    }
   96     93   
}
          94  +
impl AliasRoutingConfiguration {
          95  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          96  +
    pub fn deserialize_with_response(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          98  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          99  +
        _status: u16,
         100  +
        _body: &[u8],
         101  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         102  +
        Self::deserialize(deserializer)
         103  +
    }
         104  +
}
   97    105   
impl AliasRoutingConfiguration {
   98    106   
    /// Creates a new builder-style object to manufacture [`AliasRoutingConfiguration`](crate::types::AliasRoutingConfiguration).
   99    107   
    pub fn builder() -> crate::types::builders::AliasRoutingConfigurationBuilder {
  100    108   
        crate::types::builders::AliasRoutingConfigurationBuilder::default()
  101    109   
    }
  102    110   
}
  103    111   
  104    112   
/// A builder for [`AliasRoutingConfiguration`](crate::types::AliasRoutingConfiguration).
  105    113   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  106    114   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_allowed_publishers.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_amazon_managed_kafka_event_source_config.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_code_signing_config.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_code_signing_policies.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_concurrency.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_cors.rs

@@ -31,31 +121,121 @@
   51     51   
    /// <p>The maximum amount of time, in seconds, that web browsers can cache results of a preflight request. By default, this is set to <code>0</code>, which means that the browser doesn't cache results.</p>
   52     52   
    pub fn max_age(&self) -> ::std::option::Option<i32> {
   53     53   
        self.max_age
   54     54   
    }
   55     55   
}
   56     56   
static CORS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   57     57   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#Cors", "com.amazonaws.lambda", "Cors");
   58     58   
static CORS_MEMBER_ALLOW_CREDENTIALS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#Cors$AllowCredentials", "com.amazonaws.lambda", "Cors"),
   60     60   
    ::aws_smithy_schema::ShapeType::Boolean,
   61         -
    "allow_credentials",
          61  +
    "AllowCredentials",
   62     62   
    0,
   63     63   
);
   64     64   
static CORS_MEMBER_ALLOW_HEADERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#Cors$AllowHeaders", "com.amazonaws.lambda", "Cors"),
   66     66   
    ::aws_smithy_schema::ShapeType::List,
   67         -
    "allow_headers",
          67  +
    "AllowHeaders",
   68     68   
    1,
   69     69   
);
   70     70   
static CORS_MEMBER_ALLOW_METHODS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#Cors$AllowMethods", "com.amazonaws.lambda", "Cors"),
   72     72   
    ::aws_smithy_schema::ShapeType::List,
   73         -
    "allow_methods",
          73  +
    "AllowMethods",
   74     74   
    2,
   75     75   
);
   76     76   
static CORS_MEMBER_ALLOW_ORIGINS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#Cors$AllowOrigins", "com.amazonaws.lambda", "Cors"),
   78     78   
    ::aws_smithy_schema::ShapeType::List,
   79         -
    "allow_origins",
          79  +
    "AllowOrigins",
   80     80   
    3,
   81     81   
);
   82     82   
static CORS_MEMBER_EXPOSE_HEADERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#Cors$ExposeHeaders", "com.amazonaws.lambda", "Cors"),
   84     84   
    ::aws_smithy_schema::ShapeType::List,
   85         -
    "expose_headers",
          85  +
    "ExposeHeaders",
   86     86   
    4,
   87     87   
);
   88     88   
static CORS_MEMBER_MAX_AGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#Cors$MaxAge", "com.amazonaws.lambda", "Cors"),
   90     90   
    ::aws_smithy_schema::ShapeType::Integer,
   91         -
    "max_age",
          91  +
    "MaxAge",
   92     92   
    5,
   93     93   
);
   94     94   
static CORS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   95     95   
    CORS_SCHEMA_ID,
   96     96   
    ::aws_smithy_schema::ShapeType::Structure,
   97     97   
    &[
   98     98   
        &CORS_MEMBER_ALLOW_CREDENTIALS,
   99     99   
        &CORS_MEMBER_ALLOW_HEADERS,
  100    100   
        &CORS_MEMBER_ALLOW_METHODS,
  101    101   
        &CORS_MEMBER_ALLOW_ORIGINS,
@@ -141,141 +279,250 @@
  161    161   
            )?;
  162    162   
        }
  163    163   
        if let Some(ref val) = self.max_age {
  164    164   
            ser.write_integer(&CORS_MEMBER_MAX_AGE, *val)?;
  165    165   
        }
  166    166   
        Ok(())
  167    167   
    }
  168    168   
}
  169    169   
impl Cors {
  170    170   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  171         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  172         -
        deserializer: &mut D,
         171  +
    pub fn deserialize(
         172  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  173    173   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  174    174   
        #[allow(unused_variables, unused_mut)]
  175    175   
        let mut builder = Self::builder();
  176    176   
        #[allow(
  177    177   
            unused_variables,
  178    178   
            unreachable_code,
  179    179   
            clippy::single_match,
  180    180   
            clippy::match_single_binding,
  181    181   
            clippy::diverging_sub_expression
  182    182   
        )]
  183         -
        deserializer.read_struct(&CORS_SCHEMA, (), |_, member, deser| {
         183  +
        deserializer.read_struct(&CORS_SCHEMA, &mut |member, deser| {
  184    184   
            match member.member_index() {
  185    185   
                Some(0) => {
  186    186   
                    builder.allow_credentials = Some(deser.read_boolean(member)?);
  187    187   
                }
  188    188   
                Some(1) => {
  189         -
                    builder.allow_headers = Some({
  190         -
                        let container = if let Some(cap) = deser.container_size() {
  191         -
                            Vec::with_capacity(cap)
  192         -
                        } else {
  193         -
                            Vec::new()
  194         -
                        };
  195         -
                        deser.read_list(member, container, |mut list, deser| {
  196         -
                            list.push(deser.read_string(member)?);
  197         -
                            Ok(list)
  198         -
                        })?
  199         -
                    });
         189  +
                    builder.allow_headers = Some(deser.read_string_list(member)?);
  200    190   
                }
  201    191   
                Some(2) => {
  202         -
                    builder.allow_methods = Some({
  203         -
                        let container = if let Some(cap) = deser.container_size() {
  204         -
                            Vec::with_capacity(cap)
  205         -
                        } else {
  206         -
                            Vec::new()
  207         -
                        };
  208         -
                        deser.read_list(member, container, |mut list, deser| {
  209         -
                            list.push(deser.read_string(member)?);
  210         -
                            Ok(list)
  211         -
                        })?
  212         -
                    });
         192  +
                    builder.allow_methods = Some(deser.read_string_list(member)?);
  213    193   
                }
  214    194   
                Some(3) => {
  215         -
                    builder.allow_origins = Some({
  216         -
                        let container = if let Some(cap) = deser.container_size() {
  217         -
                            Vec::with_capacity(cap)
  218         -
                        } else {
  219         -
                            Vec::new()
  220         -
                        };
  221         -
                        deser.read_list(member, container, |mut list, deser| {
  222         -
                            list.push(deser.read_string(member)?);
  223         -
                            Ok(list)
  224         -
                        })?
  225         -
                    });
         195  +
                    builder.allow_origins = Some(deser.read_string_list(member)?);
  226    196   
                }
  227    197   
                Some(4) => {
  228         -
                    builder.expose_headers = Some({
  229         -
                        let container = if let Some(cap) = deser.container_size() {
  230         -
                            Vec::with_capacity(cap)
  231         -
                        } else {
  232         -
                            Vec::new()
  233         -
                        };
  234         -
                        deser.read_list(member, container, |mut list, deser| {
  235         -
                            list.push(deser.read_string(member)?);
  236         -
                            Ok(list)
  237         -
                        })?
  238         -
                    });
         198  +
                    builder.expose_headers = Some(deser.read_string_list(member)?);
  239    199   
                }
  240    200   
                Some(5) => {
  241    201   
                    builder.max_age = Some(deser.read_integer(member)?);
  242    202   
                }
  243    203   
                _ => {}
  244    204   
            }
  245    205   
            Ok(())
  246    206   
        })?;
  247    207   
        Ok(builder.build())
  248    208   
    }
  249    209   
}
         210  +
impl Cors {
         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  +
}
  250    221   
impl Cors {
  251    222   
    /// Creates a new builder-style object to manufacture [`Cors`](crate::types::Cors).
  252    223   
    pub fn builder() -> crate::types::builders::CorsBuilder {
  253    224   
        crate::types::builders::CorsBuilder::default()
  254    225   
    }
  255    226   
}
  256    227   
  257    228   
/// A builder for [`Cors`](crate::types::Cors).
  258    229   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  259    230   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_dead_letter_config.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_destination_config.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_document_db_event_source_config.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_environment.rs

@@ -1,1 +126,127 @@
   18     18   
        let mut formatter = f.debug_struct("Environment");
   19     19   
        formatter.field("variables", &"*** Sensitive Data Redacted ***");
   20     20   
        formatter.finish()
   21     21   
    }
   22     22   
}
   23     23   
static ENVIRONMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   24     24   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#Environment", "com.amazonaws.lambda", "Environment");
   25     25   
static ENVIRONMENT_MEMBER_VARIABLES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   26     26   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#Environment$Variables", "com.amazonaws.lambda", "Environment"),
   27     27   
    ::aws_smithy_schema::ShapeType::Map,
   28         -
    "variables",
          28  +
    "Variables",
   29     29   
    0,
   30     30   
);
   31     31   
static ENVIRONMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    ENVIRONMENT_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&ENVIRONMENT_MEMBER_VARIABLES],
   35     35   
);
   36     36   
impl Environment {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ENVIRONMENT_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for Environment {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.variables {
   47     47   
            ser.write_map(
   48     48   
                &ENVIRONMENT_MEMBER_VARIABLES,
   49     49   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   50     50   
                    for (key, value) in val {
   51     51   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   52     52   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
   53     53   
                    }
   54     54   
                    Ok(())
   55     55   
                },
   56     56   
            )?;
   57     57   
        }
   58     58   
        Ok(())
   59     59   
    }
   60     60   
}
   61     61   
impl Environment {
   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(&ENVIRONMENT_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&ENVIRONMENT_SCHEMA, &mut |member, deser| {
   76     76   
            match member.member_index() {
   77     77   
                Some(0) => {
   78         -
                    builder.variables = Some({
   79         -
                        let container = if let Some(cap) = deser.container_size() {
   80         -
                            std::collections::HashMap::with_capacity(cap)
   81         -
                        } else {
   82         -
                            std::collections::HashMap::new()
   83         -
                        };
   84         -
                        deser.read_map(member, container, |mut map, key, deser| {
   85         -
                            map.insert(key, deser.read_string(member)?);
   86         -
                            Ok(map)
   87         -
                        })?
   88         -
                    });
          78  +
                    builder.variables = Some(deser.read_string_string_map(member)?);
   89     79   
                }
   90     80   
                _ => {}
   91     81   
            }
   92     82   
            Ok(())
   93     83   
        })?;
   94     84   
        Ok(builder.build())
   95     85   
    }
   96     86   
}
          87  +
impl Environment {
          88  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          89  +
    pub fn deserialize_with_response(
          90  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          91  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          92  +
        _status: u16,
          93  +
        _body: &[u8],
          94  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          95  +
        Self::deserialize(deserializer)
          96  +
    }
          97  +
}
   97     98   
impl Environment {
   98     99   
    /// Creates a new builder-style object to manufacture [`Environment`](crate::types::Environment).
   99    100   
    pub fn builder() -> crate::types::builders::EnvironmentBuilder {
  100    101   
        crate::types::builders::EnvironmentBuilder::default()
  101    102   
    }
  102    103   
}
  103    104   
  104    105   
/// A builder for [`Environment`](crate::types::Environment).
  105    106   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  106    107   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_environment_error.rs

@@ -9,9 +134,145 @@
   29     29   
}
   30     30   
static ENVIRONMENTERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#EnvironmentError", "com.amazonaws.lambda", "EnvironmentError");
   32     32   
static ENVIRONMENTERROR_MEMBER_ERROR_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.lambda#EnvironmentError$ErrorCode",
   35     35   
        "com.amazonaws.lambda",
   36     36   
        "EnvironmentError",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "error_code",
          39  +
    "ErrorCode",
   40     40   
    0,
   41     41   
);
   42     42   
static ENVIRONMENTERROR_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.lambda#EnvironmentError$Message",
   45     45   
        "com.amazonaws.lambda",
   46     46   
        "EnvironmentError",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "message",
          49  +
    "Message",
   50     50   
    1,
   51     51   
);
   52     52   
static ENVIRONMENTERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   53     53   
    ENVIRONMENTERROR_SCHEMA_ID,
   54     54   
    ::aws_smithy_schema::ShapeType::Structure,
   55     55   
    &[&ENVIRONMENTERROR_MEMBER_ERROR_CODE, &ENVIRONMENTERROR_MEMBER_MESSAGE],
   56     56   
);
   57     57   
impl EnvironmentError {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ENVIRONMENTERROR_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for EnvironmentError {
   62     62   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   63     63   
    fn serialize_members(
   64     64   
        &self,
   65     65   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   66     66   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        if let Some(ref val) = self.error_code {
   68     68   
            ser.write_string(&ENVIRONMENTERROR_MEMBER_ERROR_CODE, val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.message {
   71     71   
            ser.write_string(&ENVIRONMENTERROR_MEMBER_MESSAGE, val)?;
   72     72   
        }
   73     73   
        Ok(())
   74     74   
    }
   75     75   
}
   76     76   
impl EnvironmentError {
   77     77   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   78         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   79         -
        deserializer: &mut D,
          78  +
    pub fn deserialize(
          79  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   80     80   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   81     81   
        #[allow(unused_variables, unused_mut)]
   82     82   
        let mut builder = Self::builder();
   83     83   
        #[allow(
   84     84   
            unused_variables,
   85     85   
            unreachable_code,
   86     86   
            clippy::single_match,
   87     87   
            clippy::match_single_binding,
   88     88   
            clippy::diverging_sub_expression
   89     89   
        )]
   90         -
        deserializer.read_struct(&ENVIRONMENTERROR_SCHEMA, (), |_, member, deser| {
          90  +
        deserializer.read_struct(&ENVIRONMENTERROR_SCHEMA, &mut |member, deser| {
   91     91   
            match member.member_index() {
   92     92   
                Some(0) => {
   93     93   
                    builder.error_code = Some(deser.read_string(member)?);
   94     94   
                }
   95     95   
                Some(1) => {
   96     96   
                    builder.message = Some(deser.read_string(member)?);
   97     97   
                }
   98     98   
                _ => {}
   99     99   
            }
  100    100   
            Ok(())
  101    101   
        })?;
  102    102   
        Ok(builder.build())
  103    103   
    }
  104    104   
}
         105  +
impl EnvironmentError {
         106  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         107  +
    pub fn deserialize_with_response(
         108  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         109  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         110  +
        _status: u16,
         111  +
        _body: &[u8],
         112  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         113  +
        Self::deserialize(deserializer)
         114  +
    }
         115  +
}
  105    116   
impl EnvironmentError {
  106    117   
    /// Creates a new builder-style object to manufacture [`EnvironmentError`](crate::types::EnvironmentError).
  107    118   
    pub fn builder() -> crate::types::builders::EnvironmentErrorBuilder {
  108    119   
        crate::types::builders::EnvironmentErrorBuilder::default()
  109    120   
    }
  110    121   
}
  111    122   
  112    123   
/// A builder for [`EnvironmentError`](crate::types::EnvironmentError).
  113    124   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  114    125   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_environment_response.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/types/_ephemeral_storage.rs

@@ -1,1 +103,115 @@
   11     11   
    /// <p>The size of the function's <code>/tmp</code> directory.</p>
   12     12   
    pub fn size(&self) -> i32 {
   13     13   
        self.size
   14     14   
    }
   15     15   
}
   16     16   
static EPHEMERALSTORAGE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#EphemeralStorage", "com.amazonaws.lambda", "EphemeralStorage");
   18     18   
static EPHEMERALSTORAGE_MEMBER_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.lambda#EphemeralStorage$Size", "com.amazonaws.lambda", "EphemeralStorage"),
   20     20   
    ::aws_smithy_schema::ShapeType::Integer,
   21         -
    "size",
          21  +
    "Size",
   22     22   
    0,
   23     23   
);
   24     24   
static EPHEMERALSTORAGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    EPHEMERALSTORAGE_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&EPHEMERALSTORAGE_MEMBER_SIZE],
   28     28   
);
   29     29   
impl EphemeralStorage {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EPHEMERALSTORAGE_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for EphemeralStorage {
   34     34   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   35     35   
    fn serialize_members(
   36     36   
        &self,
   37     37   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   38     38   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   39     39   
        {
   40     40   
            let val = &self.size;
   41     41   
            ser.write_integer(&EPHEMERALSTORAGE_MEMBER_SIZE, *val)?;
   42     42   
        }
   43     43   
        Ok(())
   44     44   
    }
   45     45   
}
   46     46   
impl EphemeralStorage {
   47     47   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   48         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   49         -
        deserializer: &mut D,
          48  +
    pub fn deserialize(
          49  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   50     50   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   51     51   
        #[allow(unused_variables, unused_mut)]
   52     52   
        let mut builder = Self::builder();
   53     53   
        #[allow(
   54     54   
            unused_variables,
   55     55   
            unreachable_code,
   56     56   
            clippy::single_match,
   57     57   
            clippy::match_single_binding,
   58     58   
            clippy::diverging_sub_expression
   59     59   
        )]
   60         -
        deserializer.read_struct(&EPHEMERALSTORAGE_SCHEMA, (), |_, member, deser| {
          60  +
        deserializer.read_struct(&EPHEMERALSTORAGE_SCHEMA, &mut |member, deser| {
   61     61   
            match member.member_index() {
   62     62   
                Some(0) => {
   63     63   
                    builder.size = Some(deser.read_integer(member)?);
   64     64   
                }
   65     65   
                _ => {}
   66     66   
            }
   67     67   
            Ok(())
   68     68   
        })?;
          69  +
        builder.size = builder.size.or(Some(0i32));
   69     70   
        builder
   70     71   
            .build()
   71     72   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   72     73   
    }
   73     74   
}
          75  +
impl EphemeralStorage {
          76  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          77  +
    pub fn deserialize_with_response(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          79  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          80  +
        _status: u16,
          81  +
        _body: &[u8],
          82  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          83  +
        Self::deserialize(deserializer)
          84  +
    }
          85  +
}
   74     86   
impl EphemeralStorage {
   75     87   
    /// Creates a new builder-style object to manufacture [`EphemeralStorage`](crate::types::EphemeralStorage).
   76     88   
    pub fn builder() -> crate::types::builders::EphemeralStorageBuilder {
   77     89   
        crate::types::builders::EphemeralStorageBuilder::default()
   78     90   
    }
   79     91   
}
   80     92   
   81     93   
/// A builder for [`EphemeralStorage`](crate::types::EphemeralStorage).
   82     94   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   83     95   
#[non_exhaustive]