AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/create_alias/_create_alias_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/create_alias/_create_alias_output.rs

@@ -29,29 +199,259 @@
   49     49   
    "com.amazonaws.lambda.synthetic",
   50     50   
    "CreateAliasOutput",
   51     51   
);
   52     52   
static CREATEALIASOUTPUT_MEMBER_ALIAS_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.lambda.synthetic#CreateAliasOutput$AliasArn",
   55     55   
        "com.amazonaws.lambda.synthetic",
   56     56   
        "CreateAliasOutput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "alias_arn",
          59  +
    "AliasArn",
   60     60   
    0,
   61     61   
);
   62     62   
static CREATEALIASOUTPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.lambda.synthetic#CreateAliasOutput$Name",
   65     65   
        "com.amazonaws.lambda.synthetic",
   66     66   
        "CreateAliasOutput",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "name",
          69  +
    "Name",
   70     70   
    1,
   71     71   
);
   72     72   
static CREATEALIASOUTPUT_MEMBER_FUNCTION_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.lambda.synthetic#CreateAliasOutput$FunctionVersion",
   75     75   
        "com.amazonaws.lambda.synthetic",
   76     76   
        "CreateAliasOutput",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "function_version",
          79  +
    "FunctionVersion",
   80     80   
    2,
   81     81   
);
   82     82   
static CREATEALIASOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.lambda.synthetic#CreateAliasOutput$Description",
   85     85   
        "com.amazonaws.lambda.synthetic",
   86     86   
        "CreateAliasOutput",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "description",
          89  +
    "Description",
   90     90   
    3,
   91     91   
);
   92     92   
static CREATEALIASOUTPUT_MEMBER_ROUTING_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.lambda.synthetic#CreateAliasOutput$RoutingConfig",
   95     95   
        "com.amazonaws.lambda.synthetic",
   96     96   
        "CreateAliasOutput",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::Structure,
   99         -
    "routing_config",
          99  +
    "RoutingConfig",
  100    100   
    4,
  101    101   
);
  102    102   
static CREATEALIASOUTPUT_MEMBER_REVISION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static(
  104    104   
        "com.amazonaws.lambda.synthetic#CreateAliasOutput$RevisionId",
  105    105   
        "com.amazonaws.lambda.synthetic",
  106    106   
        "CreateAliasOutput",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "revision_id",
         109  +
    "RevisionId",
  110    110   
    5,
  111    111   
);
         112  +
static CREATEALIASOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         113  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         114  +
    ::aws_smithy_schema::ShapeType::String,
         115  +
    "request_id",
         116  +
    6,
         117  +
)
         118  +
.with_http_header("x-amzn-requestid");
  112    119   
static CREATEALIASOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  113    120   
    CREATEALIASOUTPUT_SCHEMA_ID,
  114    121   
    ::aws_smithy_schema::ShapeType::Structure,
  115    122   
    &[
  116    123   
        &CREATEALIASOUTPUT_MEMBER_ALIAS_ARN,
  117    124   
        &CREATEALIASOUTPUT_MEMBER_NAME,
  118    125   
        &CREATEALIASOUTPUT_MEMBER_FUNCTION_VERSION,
  119    126   
        &CREATEALIASOUTPUT_MEMBER_DESCRIPTION,
  120    127   
        &CREATEALIASOUTPUT_MEMBER_ROUTING_CONFIG,
  121    128   
        &CREATEALIASOUTPUT_MEMBER_REVISION_ID,
         129  +
        &CREATEALIASOUTPUT_MEMBER__REQUEST_ID,
  122    130   
    ],
  123    131   
);
  124    132   
impl CreateAliasOutput {
  125    133   
    /// The schema for this shape.
  126    134   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEALIASOUTPUT_SCHEMA;
  127    135   
}
  128    136   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAliasOutput {
  129    137   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  130    138   
    fn serialize_members(
  131    139   
        &self,
  132    140   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  133    141   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  134    142   
        if let Some(ref val) = self.alias_arn {
  135    143   
            ser.write_string(&CREATEALIASOUTPUT_MEMBER_ALIAS_ARN, val)?;
  136    144   
        }
  137    145   
        if let Some(ref val) = self.name {
  138    146   
            ser.write_string(&CREATEALIASOUTPUT_MEMBER_NAME, val)?;
  139    147   
        }
  140    148   
        if let Some(ref val) = self.function_version {
  141    149   
            ser.write_string(&CREATEALIASOUTPUT_MEMBER_FUNCTION_VERSION, val)?;
  142    150   
        }
  143    151   
        if let Some(ref val) = self.description {
  144    152   
            ser.write_string(&CREATEALIASOUTPUT_MEMBER_DESCRIPTION, val)?;
  145    153   
        }
  146    154   
        if let Some(ref val) = self.routing_config {
  147    155   
            ser.write_struct(&CREATEALIASOUTPUT_MEMBER_ROUTING_CONFIG, val)?;
  148    156   
        }
  149    157   
        if let Some(ref val) = self.revision_id {
  150    158   
            ser.write_string(&CREATEALIASOUTPUT_MEMBER_REVISION_ID, val)?;
  151    159   
        }
  152    160   
        Ok(())
  153    161   
    }
  154    162   
}
  155    163   
impl CreateAliasOutput {
  156    164   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  157         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  158         -
        deserializer: &mut D,
         165  +
    pub fn deserialize(
         166  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         167  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         168  +
        #[allow(unused_variables, unused_mut)]
         169  +
        let mut builder = Self::builder();
         170  +
        #[allow(
         171  +
            unused_variables,
         172  +
            unreachable_code,
         173  +
            clippy::single_match,
         174  +
            clippy::match_single_binding,
         175  +
            clippy::diverging_sub_expression
         176  +
        )]
         177  +
        deserializer.read_struct(&CREATEALIASOUTPUT_SCHEMA, &mut |member, deser| {
         178  +
            match member.member_index() {
         179  +
                Some(0) => {
         180  +
                    builder.alias_arn = Some(deser.read_string(member)?);
         181  +
                }
         182  +
                Some(1) => {
         183  +
                    builder.name = Some(deser.read_string(member)?);
         184  +
                }
         185  +
                Some(2) => {
         186  +
                    builder.function_version = Some(deser.read_string(member)?);
         187  +
                }
         188  +
                Some(3) => {
         189  +
                    builder.description = Some(deser.read_string(member)?);
         190  +
                }
         191  +
                Some(4) => {
         192  +
                    builder.routing_config = Some(crate::types::AliasRoutingConfiguration::deserialize(deser)?);
         193  +
                }
         194  +
                Some(5) => {
         195  +
                    builder.revision_id = Some(deser.read_string(member)?);
         196  +
                }
         197  +
                Some(6) => {
         198  +
                    builder._request_id = Some(deser.read_string(member)?);
         199  +
                }
         200  +
                _ => {}
         201  +
            }
         202  +
            Ok(())
         203  +
        })?;
         204  +
        Ok(builder.build())
         205  +
    }
         206  +
}
         207  +
impl CreateAliasOutput {
         208  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         209  +
    /// Header-bound members are read directly from headers, avoiding runtime
         210  +
    /// member iteration overhead. Body members are read via the deserializer.
         211  +
    pub fn deserialize_with_response(
         212  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         213  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         214  +
        _status: u16,
         215  +
        _body: &[u8],
  159    216   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  160    217   
        #[allow(unused_variables, unused_mut)]
  161    218   
        let mut builder = Self::builder();
         219  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         220  +
            builder._request_id = Some(val.to_string());
         221  +
        }
  162    222   
        #[allow(
  163    223   
            unused_variables,
  164    224   
            unreachable_code,
  165    225   
            clippy::single_match,
  166    226   
            clippy::match_single_binding,
  167    227   
            clippy::diverging_sub_expression
  168    228   
        )]
  169         -
        deserializer.read_struct(&CREATEALIASOUTPUT_SCHEMA, (), |_, member, deser| {
         229  +
        deserializer.read_struct(&CREATEALIASOUTPUT_SCHEMA, &mut |member, deser| {
  170    230   
            match member.member_index() {
  171    231   
                Some(0) => {
  172    232   
                    builder.alias_arn = Some(deser.read_string(member)?);
  173    233   
                }
  174    234   
                Some(1) => {
  175    235   
                    builder.name = Some(deser.read_string(member)?);
  176    236   
                }
  177    237   
                Some(2) => {
  178    238   
                    builder.function_version = Some(deser.read_string(member)?);
  179    239   
                }

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/create_code_signing_config.rs

@@ -1,1 +40,45 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `CreateCodeSigningConfig`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateCodeSigningConfig;
    6      6   
impl CreateCodeSigningConfig {
    7      7   
    /// Creates a new `CreateCodeSigningConfig`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::create_code_signing_config::CreateCodeSigningConfigInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          15  +
        crate::operation::create_code_signing_config::CreateCodeSigningConfigOutput::SCHEMA;
   11     16   
    pub(crate) async fn orchestrate(
   12     17   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     18   
        input: crate::operation::create_code_signing_config::CreateCodeSigningConfigInput,
   14     19   
    ) -> ::std::result::Result<
   15     20   
        crate::operation::create_code_signing_config::CreateCodeSigningConfigOutput,
   16     21   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     22   
            crate::operation::create_code_signing_config::CreateCodeSigningConfigError,
   18     23   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     24   
        >,
   20     25   
    > {
@@ -118,123 +242,313 @@
  138    143   
                crate::operation::create_code_signing_config::CreateCodeSigningConfigError,
  139    144   
            >::new());
  140    145   
  141    146   
        ::std::borrow::Cow::Owned(rcb)
  142    147   
    }
  143    148   
}
  144    149   
  145    150   
#[derive(Debug)]
  146    151   
struct CreateCodeSigningConfigResponseDeserializer;
  147    152   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateCodeSigningConfigResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         153  +
    fn deserialize_nonstreaming_with_config(
  149    154   
        &self,
  150    155   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         156  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    157   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    158   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153         -
        let headers = response.headers();
  154         -
        let body = response.body().bytes().expect("body loaded");
  155    159   
        #[allow(unused_mut)]
  156    160   
        let mut force_error = false;
  157    161   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158         -
        let parse_result = if !success && status != 201 || force_error {
  159         -
            crate::protocol_serde::shape_create_code_signing_config::de_create_code_signing_config_http_error(status, headers, body)
  160         -
        } else {
  161         -
            crate::protocol_serde::shape_create_code_signing_config::de_create_code_signing_config_http_response(status, headers, body)
         162  +
        if !success && status != 201 || force_error {
         163  +
            let headers = response.headers();
         164  +
            let body = response.body().bytes().expect("body loaded");
         165  +
            #[allow(unused_mut)]
         166  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         167  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         168  +
            })?;
         169  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         170  +
            let generic = generic_builder.build();
         171  +
            let error_code = match generic.code() {
         172  +
                ::std::option::Option::Some(code) => code,
         173  +
                ::std::option::Option::None => {
         174  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         175  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         176  +
                            crate::operation::create_code_signing_config::CreateCodeSigningConfigError::unhandled(generic),
         177  +
                        ),
         178  +
                    ))
         179  +
                }
  162    180   
            };
  163         -
        crate::protocol_serde::type_erase_result(parse_result)
         181  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         182  +
            let protocol = _cfg
         183  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         184  +
                .expect("a SharedClientProtocol is required");
         185  +
            let err = match error_code {
         186  +
                "InvalidParameterValueException" => {
         187  +
                    crate::operation::create_code_signing_config::CreateCodeSigningConfigError::InvalidParameterValueException({
         188  +
                        let mut tmp = match protocol
         189  +
                            .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
         190  +
                            .and_then(|mut deser| {
         191  +
                                crate::types::error::InvalidParameterValueException::deserialize_with_response(
         192  +
                                    &mut *deser,
         193  +
                                    response.headers(),
         194  +
                                    response.status().into(),
         195  +
                                    body,
         196  +
                                )
         197  +
                            }) {
         198  +
                            ::std::result::Result::Ok(val) => val,
         199  +
                            ::std::result::Result::Err(e) => {
         200  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         201  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         202  +
                                ))
         203  +
                            }
         204  +
                        };
         205  +
                        tmp.meta = generic;
         206  +
                        if tmp.message.is_none() {
         207  +
                            tmp.message = _error_message;
         208  +
                        }
         209  +
                        tmp
         210  +
                    })
         211  +
                }
         212  +
                "ServiceException" => crate::operation::create_code_signing_config::CreateCodeSigningConfigError::ServiceException({
         213  +
                    let mut tmp = match protocol
         214  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         215  +
                        .and_then(|mut deser| {
         216  +
                            crate::types::error::ServiceException::deserialize_with_response(
         217  +
                                &mut *deser,
         218  +
                                response.headers(),
         219  +
                                response.status().into(),
         220  +
                                body,
         221  +
                            )
         222  +
                        }) {
         223  +
                        ::std::result::Result::Ok(val) => val,
         224  +
                        ::std::result::Result::Err(e) => {
         225  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         226  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         227  +
                            ))
         228  +
                        }
         229  +
                    };
         230  +
                    tmp.meta = generic;
         231  +
                    if tmp.message.is_none() {
         232  +
                        tmp.message = _error_message;
         233  +
                    }
         234  +
                    tmp
         235  +
                }),
         236  +
                _ => crate::operation::create_code_signing_config::CreateCodeSigningConfigError::generic(generic),
         237  +
            };
         238  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         239  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         240  +
            ))
         241  +
        } else {
         242  +
            let protocol = _cfg
         243  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         244  +
                .expect("a SharedClientProtocol is required");
         245  +
            let mut deser = protocol
         246  +
                .deserialize_response(response, CreateCodeSigningConfig::OUTPUT_SCHEMA, _cfg)
         247  +
                .map_err(|e| {
         248  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         249  +
                })?;
         250  +
            let body = response.body().bytes().expect("body loaded");
         251  +
            let output = crate::operation::create_code_signing_config::CreateCodeSigningConfigOutput::deserialize_with_response(
         252  +
                &mut *deser,
         253  +
                response.headers(),
         254  +
                response.status().into(),
         255  +
                body,
         256  +
            )
         257  +
            .map_err(|e| {
         258  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         259  +
            })?;
         260  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         261  +
        }
  164    262   
    }
  165    263   
}
  166    264   
#[derive(Debug)]
  167    265   
struct CreateCodeSigningConfigRequestSerializer;
  168    266   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateCodeSigningConfigRequestSerializer {
  169    267   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  170    268   
    fn serialize_input(
  171    269   
        &self,
  172    270   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  173    271   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  174    272   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  175    273   
        let input = input
  176    274   
            .downcast::<crate::operation::create_code_signing_config::CreateCodeSigningConfigInput>()
  177    275   
            .expect("correct type");
  178         -
        let _header_serialization_settings = _cfg
  179         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  180         -
            .cloned()
  181         -
            .unwrap_or_default();
  182         -
        let mut request_builder = {
  183         -
            #[allow(clippy::uninlined_format_args)]
  184         -
            fn uri_base(
  185         -
                _input: &crate::operation::create_code_signing_config::CreateCodeSigningConfigInput,
  186         -
                output: &mut ::std::string::String,
  187         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188         -
                use ::std::fmt::Write as _;
  189         -
                ::std::write!(output, "/2020-04-22/code-signing-configs").expect("formatting should succeed");
  190         -
                ::std::result::Result::Ok(())
  191         -
            }
  192         -
            #[allow(clippy::unnecessary_wraps)]
  193         -
            fn update_http_builder(
  194         -
                input: &crate::operation::create_code_signing_config::CreateCodeSigningConfigInput,
  195         -
                builder: ::http_1x::request::Builder,
  196         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197         -
                let mut uri = ::std::string::String::new();
  198         -
                uri_base(input, &mut uri)?;
  199         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200         -
            }
  201         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  203         -
            builder
  204         -
        };
  205         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  206         -
            crate::protocol_serde::shape_create_code_signing_config::ser_create_code_signing_config_input(&input)?,
  207         -
        );
  208         -
        if let Some(content_length) = body.content_length() {
  209         -
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211         -
        }
  212         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         276  +
        let protocol = _cfg
         277  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         278  +
            .expect("a SharedClientProtocol is required");
         279  +
        let mut request = protocol
         280  +
            .serialize_request(&input, CreateCodeSigningConfig::INPUT_SCHEMA, "", _cfg)
         281  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         282  +
         283  +
        return ::std::result::Result::Ok(request);
  213    284   
    }
  214    285   
}
  215    286   
#[derive(Debug)]
  216    287   
struct CreateCodeSigningConfigEndpointParamsInterceptor;
  217    288   
  218    289   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateCodeSigningConfigEndpointParamsInterceptor {
  219    290   
    fn name(&self) -> &'static str {
  220    291   
        "CreateCodeSigningConfigEndpointParamsInterceptor"
  221    292   
    }
  222    293

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/create_code_signing_config/_create_code_signing_config_input.rs

@@ -15,15 +198,204 @@
   35     35   
    "com.amazonaws.lambda.synthetic",
   36     36   
    "CreateCodeSigningConfigInput",
   37     37   
);
   38     38   
static CREATECODESIGNINGCONFIGINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   39     39   
    ::aws_smithy_schema::ShapeId::from_static(
   40     40   
        "com.amazonaws.lambda.synthetic#CreateCodeSigningConfigInput$Description",
   41     41   
        "com.amazonaws.lambda.synthetic",
   42     42   
        "CreateCodeSigningConfigInput",
   43     43   
    ),
   44     44   
    ::aws_smithy_schema::ShapeType::String,
   45         -
    "description",
          45  +
    "Description",
   46     46   
    0,
   47     47   
);
   48     48   
static CREATECODESIGNINGCONFIGINPUT_MEMBER_ALLOWED_PUBLISHERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.lambda.synthetic#CreateCodeSigningConfigInput$AllowedPublishers",
   51     51   
        "com.amazonaws.lambda.synthetic",
   52     52   
        "CreateCodeSigningConfigInput",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::Structure,
   55         -
    "allowed_publishers",
          55  +
    "AllowedPublishers",
   56     56   
    1,
   57     57   
);
   58     58   
static CREATECODESIGNINGCONFIGINPUT_MEMBER_CODE_SIGNING_POLICIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.lambda.synthetic#CreateCodeSigningConfigInput$CodeSigningPolicies",
   61     61   
        "com.amazonaws.lambda.synthetic",
   62     62   
        "CreateCodeSigningConfigInput",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65         -
    "code_signing_policies",
          65  +
    "CodeSigningPolicies",
   66     66   
    2,
   67     67   
);
   68     68   
static CREATECODESIGNINGCONFIGINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.lambda.synthetic#CreateCodeSigningConfigInput$Tags",
   71     71   
        "com.amazonaws.lambda.synthetic",
   72     72   
        "CreateCodeSigningConfigInput",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::Map,
   75         -
    "tags",
          75  +
    "Tags",
   76     76   
    3,
   77     77   
);
   78     78   
static CREATECODESIGNINGCONFIGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   79     79   
    CREATECODESIGNINGCONFIGINPUT_SCHEMA_ID,
   80     80   
    ::aws_smithy_schema::ShapeType::Structure,
   81     81   
    &[
   82     82   
        &CREATECODESIGNINGCONFIGINPUT_MEMBER_DESCRIPTION,
   83     83   
        &CREATECODESIGNINGCONFIGINPUT_MEMBER_ALLOWED_PUBLISHERS,
   84     84   
        &CREATECODESIGNINGCONFIGINPUT_MEMBER_CODE_SIGNING_POLICIES,
   85     85   
        &CREATECODESIGNINGCONFIGINPUT_MEMBER_TAGS,
   86     86   
    ],
   87         -
);
          87  +
)
          88  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          89  +
    "POST",
          90  +
    "/2020-04-22/code-signing-configs",
          91  +
    Some(201),
          92  +
));
   88     93   
impl CreateCodeSigningConfigInput {
   89     94   
    /// The schema for this shape.
   90     95   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATECODESIGNINGCONFIGINPUT_SCHEMA;
   91     96   
}
   92     97   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateCodeSigningConfigInput {
   93     98   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   94     99   
    fn serialize_members(
   95    100   
        &self,
   96    101   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   97    102   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   98    103   
        if let Some(ref val) = self.description {
   99    104   
            ser.write_string(&CREATECODESIGNINGCONFIGINPUT_MEMBER_DESCRIPTION, val)?;
  100    105   
        }
  101    106   
        if let Some(ref val) = self.allowed_publishers {
  102    107   
            ser.write_struct(&CREATECODESIGNINGCONFIGINPUT_MEMBER_ALLOWED_PUBLISHERS, val)?;
  103    108   
        }
  104    109   
        if let Some(ref val) = self.code_signing_policies {
  105    110   
            ser.write_struct(&CREATECODESIGNINGCONFIGINPUT_MEMBER_CODE_SIGNING_POLICIES, val)?;
  106    111   
        }
  107    112   
        if let Some(ref val) = self.tags {
  108    113   
            ser.write_map(
  109    114   
                &CREATECODESIGNINGCONFIGINPUT_MEMBER_TAGS,
  110    115   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  111    116   
                    for (key, value) in val {
  112    117   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  113    118   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
  114    119   
                    }
  115    120   
                    Ok(())
  116    121   
                },
  117    122   
            )?;
  118    123   
        }
  119    124   
        Ok(())
  120    125   
    }
  121    126   
}
  122    127   
impl CreateCodeSigningConfigInput {
  123    128   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  124         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  125         -
        deserializer: &mut D,
         129  +
    pub fn deserialize(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  126    131   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  127    132   
        #[allow(unused_variables, unused_mut)]
  128    133   
        let mut builder = Self::builder();
  129    134   
        #[allow(
  130    135   
            unused_variables,
  131    136   
            unreachable_code,
  132    137   
            clippy::single_match,
  133    138   
            clippy::match_single_binding,
  134    139   
            clippy::diverging_sub_expression
  135    140   
        )]
  136         -
        deserializer.read_struct(&CREATECODESIGNINGCONFIGINPUT_SCHEMA, (), |_, member, deser| {
         141  +
        deserializer.read_struct(&CREATECODESIGNINGCONFIGINPUT_SCHEMA, &mut |member, deser| {
  137    142   
            match member.member_index() {
  138    143   
                Some(0) => {
  139    144   
                    builder.description = Some(deser.read_string(member)?);
  140    145   
                }
  141    146   
                Some(1) => {
  142    147   
                    builder.allowed_publishers = Some(crate::types::AllowedPublishers::deserialize(deser)?);
  143    148   
                }
  144    149   
                Some(2) => {
  145    150   
                    builder.code_signing_policies = Some(crate::types::CodeSigningPolicies::deserialize(deser)?);
  146    151   
                }
  147    152   
                Some(3) => {
  148         -
                    builder.tags = Some({
  149         -
                        let container = if let Some(cap) = deser.container_size() {
  150         -
                            std::collections::HashMap::with_capacity(cap)
  151         -
                        } else {
  152         -
                            std::collections::HashMap::new()
  153         -
                        };
  154         -
                        deser.read_map(member, container, |mut map, key, deser| {
  155         -
                            map.insert(key, deser.read_string(member)?);
  156         -
                            Ok(map)
  157         -
                        })?
  158         -
                    });
         153  +
                    builder.tags = Some(deser.read_string_string_map(member)?);
  159    154   
                }
  160    155   
                _ => {}
  161    156   
            }
  162    157   
            Ok(())
  163    158   
        })?;
  164    159   
        builder
  165    160   
            .build()
  166    161   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  167    162   
    }
  168    163   
}
         164  +
impl CreateCodeSigningConfigInput {
         165  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         166  +
    pub fn deserialize_with_response(
         167  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         168  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         169  +
        _status: u16,
         170  +
        _body: &[u8],
         171  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         172  +
        Self::deserialize(deserializer)
         173  +
    }
         174  +
}
  169    175   
impl CreateCodeSigningConfigInput {
  170    176   
    /// Creates a new builder-style object to manufacture [`CreateCodeSigningConfigInput`](crate::operation::create_code_signing_config::CreateCodeSigningConfigInput).
  171    177   
    pub fn builder() -> crate::operation::create_code_signing_config::builders::CreateCodeSigningConfigInputBuilder {
  172    178   
        crate::operation::create_code_signing_config::builders::CreateCodeSigningConfigInputBuilder::default()
  173    179   
    }
  174    180   
}
  175    181   
  176    182   
/// A builder for [`CreateCodeSigningConfigInput`](crate::operation::create_code_signing_config::CreateCodeSigningConfigInput).
  177    183   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  178    184   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/create_code_signing_config/_create_code_signing_config_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/create_event_source_mapping.rs

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `CreateEventSourceMapping`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct CreateEventSourceMapping;
    6      6   
impl CreateEventSourceMapping {
    7      7   
    /// Creates a new `CreateEventSourceMapping`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::create_event_source_mapping::CreateEventSourceMappingInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::create_event_source_mapping::CreateEventSourceMappingOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::create_event_source_mapping::CreateEventSourceMappingInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::create_event_source_mapping::CreateEventSourceMappingOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::create_event_source_mapping::CreateEventSourceMappingError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -118,124 +242,392 @@
  138    144   
                crate::operation::create_event_source_mapping::CreateEventSourceMappingError,
  139    145   
            >::new());
  140    146   
  141    147   
        ::std::borrow::Cow::Owned(rcb)
  142    148   
    }
  143    149   
}
  144    150   
  145    151   
#[derive(Debug)]
  146    152   
struct CreateEventSourceMappingResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CreateEventSourceMappingResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         154  +
    fn deserialize_nonstreaming_with_config(
  149    155   
        &self,
  150    156   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         157  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    158   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    159   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153         -
        let headers = response.headers();
  154         -
        let body = response.body().bytes().expect("body loaded");
  155    160   
        #[allow(unused_mut)]
  156    161   
        let mut force_error = false;
  157    162   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158         -
        let parse_result = if !success && status != 202 || force_error {
  159         -
            crate::protocol_serde::shape_create_event_source_mapping::de_create_event_source_mapping_http_error(status, headers, body)
  160         -
        } else {
  161         -
            crate::protocol_serde::shape_create_event_source_mapping::de_create_event_source_mapping_http_response(status, headers, body)
         163  +
        if !success && status != 202 || force_error {
         164  +
            let headers = response.headers();
         165  +
            let body = response.body().bytes().expect("body loaded");
         166  +
            #[allow(unused_mut)]
         167  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         168  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         169  +
            })?;
         170  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         171  +
            let generic = generic_builder.build();
         172  +
            let error_code = match generic.code() {
         173  +
                ::std::option::Option::Some(code) => code,
         174  +
                ::std::option::Option::None => {
         175  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         176  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         177  +
                            crate::operation::create_event_source_mapping::CreateEventSourceMappingError::unhandled(generic),
         178  +
                        ),
         179  +
                    ))
         180  +
                }
         181  +
            };
         182  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         183  +
            let protocol = _cfg
         184  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         185  +
                .expect("a SharedClientProtocol is required");
         186  +
            let err = match error_code {
         187  +
                "InvalidParameterValueException" => {
         188  +
                    crate::operation::create_event_source_mapping::CreateEventSourceMappingError::InvalidParameterValueException({
         189  +
                        let mut tmp = match protocol
         190  +
                            .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
         191  +
                            .and_then(|mut deser| {
         192  +
                                crate::types::error::InvalidParameterValueException::deserialize_with_response(
         193  +
                                    &mut *deser,
         194  +
                                    response.headers(),
         195  +
                                    response.status().into(),
         196  +
                                    body,
         197  +
                                )
         198  +
                            }) {
         199  +
                            ::std::result::Result::Ok(val) => val,
         200  +
                            ::std::result::Result::Err(e) => {
         201  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         202  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         203  +
                                ))
         204  +
                            }
         205  +
                        };
         206  +
                        tmp.meta = generic;
         207  +
                        if tmp.message.is_none() {
         208  +
                            tmp.message = _error_message;
         209  +
                        }
         210  +
                        tmp
         211  +
                    })
         212  +
                }
         213  +
                "ResourceConflictException" => {
         214  +
                    crate::operation::create_event_source_mapping::CreateEventSourceMappingError::ResourceConflictException({
         215  +
                        let mut tmp = match protocol
         216  +
                            .deserialize_response(response, crate::types::error::ResourceConflictException::SCHEMA, _cfg)
         217  +
                            .and_then(|mut deser| {
         218  +
                                crate::types::error::ResourceConflictException::deserialize_with_response(
         219  +
                                    &mut *deser,
         220  +
                                    response.headers(),
         221  +
                                    response.status().into(),
         222  +
                                    body,
         223  +
                                )
         224  +
                            }) {
         225  +
                            ::std::result::Result::Ok(val) => val,
         226  +
                            ::std::result::Result::Err(e) => {
         227  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         228  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         229  +
                                ))
         230  +
                            }
         231  +
                        };
         232  +
                        tmp.meta = generic;
         233  +
                        if tmp.message.is_none() {
         234  +
                            tmp.message = _error_message;
         235  +
                        }
         236  +
                        tmp
         237  +
                    })
         238  +
                }
         239  +
                "ResourceNotFoundException" => {
         240  +
                    crate::operation::create_event_source_mapping::CreateEventSourceMappingError::ResourceNotFoundException({
         241  +
                        let mut tmp = match protocol
         242  +
                            .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         243  +
                            .and_then(|mut deser| {
         244  +
                                crate::types::error::ResourceNotFoundException::deserialize_with_response(
         245  +
                                    &mut *deser,
         246  +
                                    response.headers(),
         247  +
                                    response.status().into(),
         248  +
                                    body,
         249  +
                                )
         250  +
                            }) {
         251  +
                            ::std::result::Result::Ok(val) => val,
         252  +
                            ::std::result::Result::Err(e) => {
         253  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         254  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         255  +
                                ))
         256  +
                            }
  162    257   
                        };
  163         -
        crate::protocol_serde::type_erase_result(parse_result)
         258  +
                        tmp.meta = generic;
         259  +
                        if tmp.message.is_none() {
         260  +
                            tmp.message = _error_message;
         261  +
                        }
         262  +
                        tmp
         263  +
                    })
         264  +
                }
         265  +
                "ServiceException" => crate::operation::create_event_source_mapping::CreateEventSourceMappingError::ServiceException({
         266  +
                    let mut tmp = match protocol
         267  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         268  +
                        .and_then(|mut deser| {
         269  +
                            crate::types::error::ServiceException::deserialize_with_response(
         270  +
                                &mut *deser,
         271  +
                                response.headers(),
         272  +
                                response.status().into(),
         273  +
                                body,
         274  +
                            )
         275  +
                        }) {
         276  +
                        ::std::result::Result::Ok(val) => val,
         277  +
                        ::std::result::Result::Err(e) => {
         278  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         279  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         280  +
                            ))
         281  +
                        }
         282  +
                    };
         283  +
                    tmp.meta = generic;
         284  +
                    if tmp.message.is_none() {
         285  +
                        tmp.message = _error_message;
         286  +
                    }
         287  +
                    tmp
         288  +
                }),
         289  +
                "TooManyRequestsException" => {
         290  +
                    crate::operation::create_event_source_mapping::CreateEventSourceMappingError::TooManyRequestsException({
         291  +
                        let mut tmp = match protocol
         292  +
                            .deserialize_response(response, crate::types::error::TooManyRequestsException::SCHEMA, _cfg)
         293  +
                            .and_then(|mut deser| {
         294  +
                                crate::types::error::TooManyRequestsException::deserialize_with_response(
         295  +
                                    &mut *deser,
         296  +
                                    response.headers(),
         297  +
                                    response.status().into(),
         298  +
                                    body,
         299  +
                                )
         300  +
                            }) {
         301  +
                            ::std::result::Result::Ok(val) => val,
         302  +
                            ::std::result::Result::Err(e) => {
         303  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         304  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         305  +
                                ))
         306  +
                            }
         307  +
                        };
         308  +
                        tmp.meta = generic;
         309  +
                        if tmp.message.is_none() {
         310  +
                            tmp.message = _error_message;
         311  +
                        }
         312  +
                        tmp
         313  +
                    })
         314  +
                }
         315  +
                _ => crate::operation::create_event_source_mapping::CreateEventSourceMappingError::generic(generic),
         316  +
            };
         317  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         318  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         319  +
            ))
         320  +
        } else {
         321  +
            let protocol = _cfg
         322  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         323  +
                .expect("a SharedClientProtocol is required");
         324  +
            let mut deser = protocol
         325  +
                .deserialize_response(response, CreateEventSourceMapping::OUTPUT_SCHEMA, _cfg)
         326  +
                .map_err(|e| {
         327  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         328  +
                })?;
         329  +
            let body = response.body().bytes().expect("body loaded");
         330  +
            let output = crate::operation::create_event_source_mapping::CreateEventSourceMappingOutput::deserialize_with_response(
         331  +
                &mut *deser,
         332  +
                response.headers(),
         333  +
                response.status().into(),
         334  +
                body,
         335  +
            )
         336  +
            .map_err(|e| {
         337  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         338  +
            })?;
         339  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         340  +
        }
  164    341   
    }
  165    342   
}
  166    343   
#[derive(Debug)]
  167    344   
struct CreateEventSourceMappingRequestSerializer;
  168    345   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CreateEventSourceMappingRequestSerializer {
  169    346   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  170    347   
    fn serialize_input(
  171    348   
        &self,
  172    349   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  173    350   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  174    351   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  175    352   
        let input = input
  176    353   
            .downcast::<crate::operation::create_event_source_mapping::CreateEventSourceMappingInput>()
  177    354   
            .expect("correct type");
  178         -
        let _header_serialization_settings = _cfg
  179         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  180         -
            .cloned()
  181         -
            .unwrap_or_default();
  182         -
        let mut request_builder = {
  183         -
            #[allow(clippy::uninlined_format_args)]
  184         -
            fn uri_base(
  185         -
                _input: &crate::operation::create_event_source_mapping::CreateEventSourceMappingInput,
  186         -
                output: &mut ::std::string::String,
  187         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188         -
                use ::std::fmt::Write as _;
  189         -
                ::std::write!(output, "/2015-03-31/event-source-mappings").expect("formatting should succeed");
  190         -
                ::std::result::Result::Ok(())
  191         -
            }
  192         -
            #[allow(clippy::unnecessary_wraps)]
  193         -
            fn update_http_builder(
  194         -
                input: &crate::operation::create_event_source_mapping::CreateEventSourceMappingInput,
  195         -
                builder: ::http_1x::request::Builder,
  196         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197         -
                let mut uri = ::std::string::String::new();
  198         -
                uri_base(input, &mut uri)?;
  199         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200         -
            }
  201         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  203         -
            builder
  204         -
        };
  205         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  206         -
            crate::protocol_serde::shape_create_event_source_mapping::ser_create_event_source_mapping_input(&input)?,
  207         -
        );
  208         -
        if let Some(content_length) = body.content_length() {
  209         -
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211         -
        }
  212         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         355  +
        let protocol = _cfg
         356  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         357  +
            .expect("a SharedClientProtocol is required");
         358  +
        let mut request = protocol
         359  +
            .serialize_request(&input, CreateEventSourceMapping::INPUT_SCHEMA, "", _cfg)
         360  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         361  +
         362  +
        return ::std::result::Result::Ok(request);
  213    363   
    }
  214    364   
}
  215    365   
#[derive(Debug)]
  216    366   
struct CreateEventSourceMappingEndpointParamsInterceptor;
  217    367   
  218    368   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateEventSourceMappingEndpointParamsInterceptor {
  219    369   
    fn name(&self) -> &'static str {
  220    370   
        "CreateEventSourceMappingEndpointParamsInterceptor"
  221    371   
    }
  222    372

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/create_event_source_mapping/_create_event_source_mapping_input.rs

@@ -251,251 +608,613 @@
  271    271   
    "com.amazonaws.lambda.synthetic",
  272    272   
    "CreateEventSourceMappingInput",
  273    273   
);
  274    274   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_EVENT_SOURCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  275    275   
    ::aws_smithy_schema::ShapeId::from_static(
  276    276   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$EventSourceArn",
  277    277   
        "com.amazonaws.lambda.synthetic",
  278    278   
        "CreateEventSourceMappingInput",
  279    279   
    ),
  280    280   
    ::aws_smithy_schema::ShapeType::String,
  281         -
    "event_source_arn",
         281  +
    "EventSourceArn",
  282    282   
    0,
  283    283   
);
  284    284   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_FUNCTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  285    285   
    ::aws_smithy_schema::ShapeId::from_static(
  286    286   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$FunctionName",
  287    287   
        "com.amazonaws.lambda.synthetic",
  288    288   
        "CreateEventSourceMappingInput",
  289    289   
    ),
  290    290   
    ::aws_smithy_schema::ShapeType::String,
  291         -
    "function_name",
         291  +
    "FunctionName",
  292    292   
    1,
  293    293   
);
  294    294   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  295    295   
    ::aws_smithy_schema::ShapeId::from_static(
  296    296   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$Enabled",
  297    297   
        "com.amazonaws.lambda.synthetic",
  298    298   
        "CreateEventSourceMappingInput",
  299    299   
    ),
  300    300   
    ::aws_smithy_schema::ShapeType::Boolean,
  301         -
    "enabled",
         301  +
    "Enabled",
  302    302   
    2,
  303    303   
);
  304    304   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_BATCH_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  305    305   
    ::aws_smithy_schema::ShapeId::from_static(
  306    306   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$BatchSize",
  307    307   
        "com.amazonaws.lambda.synthetic",
  308    308   
        "CreateEventSourceMappingInput",
  309    309   
    ),
  310    310   
    ::aws_smithy_schema::ShapeType::Integer,
  311         -
    "batch_size",
         311  +
    "BatchSize",
  312    312   
    3,
  313    313   
);
  314    314   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_FILTER_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  315    315   
    ::aws_smithy_schema::ShapeId::from_static(
  316    316   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$FilterCriteria",
  317    317   
        "com.amazonaws.lambda.synthetic",
  318    318   
        "CreateEventSourceMappingInput",
  319    319   
    ),
  320    320   
    ::aws_smithy_schema::ShapeType::Structure,
  321         -
    "filter_criteria",
         321  +
    "FilterCriteria",
  322    322   
    4,
  323    323   
);
  324    324   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_BATCHING_WINDOW_IN_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  325    325   
    ::aws_smithy_schema::ShapeId::from_static(
  326    326   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$MaximumBatchingWindowInSeconds",
  327    327   
        "com.amazonaws.lambda.synthetic",
  328    328   
        "CreateEventSourceMappingInput",
  329    329   
    ),
  330    330   
    ::aws_smithy_schema::ShapeType::Integer,
  331         -
    "maximum_batching_window_in_seconds",
         331  +
    "MaximumBatchingWindowInSeconds",
  332    332   
    5,
  333    333   
);
  334    334   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_PARALLELIZATION_FACTOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  335    335   
    ::aws_smithy_schema::ShapeId::from_static(
  336    336   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$ParallelizationFactor",
  337    337   
        "com.amazonaws.lambda.synthetic",
  338    338   
        "CreateEventSourceMappingInput",
  339    339   
    ),
  340    340   
    ::aws_smithy_schema::ShapeType::Integer,
  341         -
    "parallelization_factor",
         341  +
    "ParallelizationFactor",
  342    342   
    6,
  343    343   
);
  344    344   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_STARTING_POSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  345    345   
    ::aws_smithy_schema::ShapeId::from_static(
  346    346   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$StartingPosition",
  347    347   
        "com.amazonaws.lambda.synthetic",
  348    348   
        "CreateEventSourceMappingInput",
  349    349   
    ),
  350    350   
    ::aws_smithy_schema::ShapeType::String,
  351         -
    "starting_position",
         351  +
    "StartingPosition",
  352    352   
    7,
  353    353   
);
  354    354   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_STARTING_POSITION_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  355    355   
    ::aws_smithy_schema::ShapeId::from_static(
  356    356   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$StartingPositionTimestamp",
  357    357   
        "com.amazonaws.lambda.synthetic",
  358    358   
        "CreateEventSourceMappingInput",
  359    359   
    ),
  360    360   
    ::aws_smithy_schema::ShapeType::Timestamp,
  361         -
    "starting_position_timestamp",
         361  +
    "StartingPositionTimestamp",
  362    362   
    8,
  363    363   
);
  364    364   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_DESTINATION_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  365    365   
    ::aws_smithy_schema::ShapeId::from_static(
  366    366   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$DestinationConfig",
  367    367   
        "com.amazonaws.lambda.synthetic",
  368    368   
        "CreateEventSourceMappingInput",
  369    369   
    ),
  370    370   
    ::aws_smithy_schema::ShapeType::Structure,
  371         -
    "destination_config",
         371  +
    "DestinationConfig",
  372    372   
    9,
  373    373   
);
  374    374   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_RECORD_AGE_IN_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  375    375   
    ::aws_smithy_schema::ShapeId::from_static(
  376    376   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$MaximumRecordAgeInSeconds",
  377    377   
        "com.amazonaws.lambda.synthetic",
  378    378   
        "CreateEventSourceMappingInput",
  379    379   
    ),
  380    380   
    ::aws_smithy_schema::ShapeType::Integer,
  381         -
    "maximum_record_age_in_seconds",
         381  +
    "MaximumRecordAgeInSeconds",
  382    382   
    10,
  383    383   
);
  384    384   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_BISECT_BATCH_ON_FUNCTION_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  385    385   
    ::aws_smithy_schema::ShapeId::from_static(
  386    386   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$BisectBatchOnFunctionError",
  387    387   
        "com.amazonaws.lambda.synthetic",
  388    388   
        "CreateEventSourceMappingInput",
  389    389   
    ),
  390    390   
    ::aws_smithy_schema::ShapeType::Boolean,
  391         -
    "bisect_batch_on_function_error",
         391  +
    "BisectBatchOnFunctionError",
  392    392   
    11,
  393    393   
);
  394    394   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_RETRY_ATTEMPTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  395    395   
    ::aws_smithy_schema::ShapeId::from_static(
  396    396   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$MaximumRetryAttempts",
  397    397   
        "com.amazonaws.lambda.synthetic",
  398    398   
        "CreateEventSourceMappingInput",
  399    399   
    ),
  400    400   
    ::aws_smithy_schema::ShapeType::Integer,
  401         -
    "maximum_retry_attempts",
         401  +
    "MaximumRetryAttempts",
  402    402   
    12,
  403    403   
);
  404    404   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  405    405   
    ::aws_smithy_schema::ShapeId::from_static(
  406    406   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$Tags",
  407    407   
        "com.amazonaws.lambda.synthetic",
  408    408   
        "CreateEventSourceMappingInput",
  409    409   
    ),
  410    410   
    ::aws_smithy_schema::ShapeType::Map,
  411         -
    "tags",
         411  +
    "Tags",
  412    412   
    13,
  413    413   
);
  414    414   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_TUMBLING_WINDOW_IN_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  415    415   
    ::aws_smithy_schema::ShapeId::from_static(
  416    416   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$TumblingWindowInSeconds",
  417    417   
        "com.amazonaws.lambda.synthetic",
  418    418   
        "CreateEventSourceMappingInput",
  419    419   
    ),
  420    420   
    ::aws_smithy_schema::ShapeType::Integer,
  421         -
    "tumbling_window_in_seconds",
         421  +
    "TumblingWindowInSeconds",
  422    422   
    14,
  423    423   
);
  424    424   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_TOPICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  425    425   
    ::aws_smithy_schema::ShapeId::from_static(
  426    426   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$Topics",
  427    427   
        "com.amazonaws.lambda.synthetic",
  428    428   
        "CreateEventSourceMappingInput",
  429    429   
    ),
  430    430   
    ::aws_smithy_schema::ShapeType::List,
  431         -
    "topics",
         431  +
    "Topics",
  432    432   
    15,
  433    433   
);
  434    434   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_QUEUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  435    435   
    ::aws_smithy_schema::ShapeId::from_static(
  436    436   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$Queues",
  437    437   
        "com.amazonaws.lambda.synthetic",
  438    438   
        "CreateEventSourceMappingInput",
  439    439   
    ),
  440    440   
    ::aws_smithy_schema::ShapeType::List,
  441         -
    "queues",
         441  +
    "Queues",
  442    442   
    16,
  443    443   
);
  444    444   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_SOURCE_ACCESS_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  445    445   
    ::aws_smithy_schema::ShapeId::from_static(
  446    446   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$SourceAccessConfigurations",
  447    447   
        "com.amazonaws.lambda.synthetic",
  448    448   
        "CreateEventSourceMappingInput",
  449    449   
    ),
  450    450   
    ::aws_smithy_schema::ShapeType::List,
  451         -
    "source_access_configurations",
         451  +
    "SourceAccessConfigurations",
  452    452   
    17,
  453    453   
);
  454    454   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_SELF_MANAGED_EVENT_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  455    455   
    ::aws_smithy_schema::ShapeId::from_static(
  456    456   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$SelfManagedEventSource",
  457    457   
        "com.amazonaws.lambda.synthetic",
  458    458   
        "CreateEventSourceMappingInput",
  459    459   
    ),
  460    460   
    ::aws_smithy_schema::ShapeType::Structure,
  461         -
    "self_managed_event_source",
         461  +
    "SelfManagedEventSource",
  462    462   
    18,
  463    463   
);
  464    464   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_FUNCTION_RESPONSE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  465    465   
    ::aws_smithy_schema::ShapeId::from_static(
  466    466   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$FunctionResponseTypes",
  467    467   
        "com.amazonaws.lambda.synthetic",
  468    468   
        "CreateEventSourceMappingInput",
  469    469   
    ),
  470    470   
    ::aws_smithy_schema::ShapeType::List,
  471         -
    "function_response_types",
         471  +
    "FunctionResponseTypes",
  472    472   
    19,
  473    473   
);
  474    474   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_AMAZON_MANAGED_KAFKA_EVENT_SOURCE_CONFIG: ::aws_smithy_schema::Schema =
  475    475   
    ::aws_smithy_schema::Schema::new_member(
  476    476   
        ::aws_smithy_schema::ShapeId::from_static(
  477    477   
            "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$AmazonManagedKafkaEventSourceConfig",
  478    478   
            "com.amazonaws.lambda.synthetic",
  479    479   
            "CreateEventSourceMappingInput",
  480    480   
        ),
  481    481   
        ::aws_smithy_schema::ShapeType::Structure,
  482         -
        "amazon_managed_kafka_event_source_config",
         482  +
        "AmazonManagedKafkaEventSourceConfig",
  483    483   
        20,
  484    484   
    );
  485    485   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_SELF_MANAGED_KAFKA_EVENT_SOURCE_CONFIG: ::aws_smithy_schema::Schema =
  486    486   
    ::aws_smithy_schema::Schema::new_member(
  487    487   
        ::aws_smithy_schema::ShapeId::from_static(
  488    488   
            "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$SelfManagedKafkaEventSourceConfig",
  489    489   
            "com.amazonaws.lambda.synthetic",
  490    490   
            "CreateEventSourceMappingInput",
  491    491   
        ),
  492    492   
        ::aws_smithy_schema::ShapeType::Structure,
  493         -
        "self_managed_kafka_event_source_config",
         493  +
        "SelfManagedKafkaEventSourceConfig",
  494    494   
        21,
  495    495   
    );
  496    496   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_SCALING_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  497    497   
    ::aws_smithy_schema::ShapeId::from_static(
  498    498   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$ScalingConfig",
  499    499   
        "com.amazonaws.lambda.synthetic",
  500    500   
        "CreateEventSourceMappingInput",
  501    501   
    ),
  502    502   
    ::aws_smithy_schema::ShapeType::Structure,
  503         -
    "scaling_config",
         503  +
    "ScalingConfig",
  504    504   
    22,
  505    505   
);
  506    506   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_DOCUMENT_DB_EVENT_SOURCE_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  507    507   
    ::aws_smithy_schema::ShapeId::from_static(
  508    508   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$DocumentDBEventSourceConfig",
  509    509   
        "com.amazonaws.lambda.synthetic",
  510    510   
        "CreateEventSourceMappingInput",
  511    511   
    ),
  512    512   
    ::aws_smithy_schema::ShapeType::Structure,
  513         -
    "document_db_event_source_config",
         513  +
    "DocumentDBEventSourceConfig",
  514    514   
    23,
  515    515   
);
  516    516   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_KMS_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  517    517   
    ::aws_smithy_schema::ShapeId::from_static(
  518    518   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$KMSKeyArn",
  519    519   
        "com.amazonaws.lambda.synthetic",
  520    520   
        "CreateEventSourceMappingInput",
  521    521   
    ),
  522    522   
    ::aws_smithy_schema::ShapeType::String,
  523         -
    "kms_key_arn",
         523  +
    "KMSKeyArn",
  524    524   
    24,
  525    525   
);
  526    526   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_METRICS_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  527    527   
    ::aws_smithy_schema::ShapeId::from_static(
  528    528   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$MetricsConfig",
  529    529   
        "com.amazonaws.lambda.synthetic",
  530    530   
        "CreateEventSourceMappingInput",
  531    531   
    ),
  532    532   
    ::aws_smithy_schema::ShapeType::Structure,
  533         -
    "metrics_config",
         533  +
    "MetricsConfig",
  534    534   
    25,
  535    535   
);
  536    536   
static CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_PROVISIONED_POLLER_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  537    537   
    ::aws_smithy_schema::ShapeId::from_static(
  538    538   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingInput$ProvisionedPollerConfig",
  539    539   
        "com.amazonaws.lambda.synthetic",
  540    540   
        "CreateEventSourceMappingInput",
  541    541   
    ),
  542    542   
    ::aws_smithy_schema::ShapeType::Structure,
  543         -
    "provisioned_poller_config",
         543  +
    "ProvisionedPollerConfig",
  544    544   
    26,
  545    545   
);
  546    546   
static CREATEEVENTSOURCEMAPPINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  547    547   
    CREATEEVENTSOURCEMAPPINGINPUT_SCHEMA_ID,
  548    548   
    ::aws_smithy_schema::ShapeType::Structure,
  549    549   
    &[
  550    550   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_EVENT_SOURCE_ARN,
  551    551   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_FUNCTION_NAME,
  552    552   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_ENABLED,
  553    553   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_BATCH_SIZE,
  554    554   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_FILTER_CRITERIA,
  555    555   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_BATCHING_WINDOW_IN_SECONDS,
  556    556   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_PARALLELIZATION_FACTOR,
  557    557   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_STARTING_POSITION,
  558    558   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_STARTING_POSITION_TIMESTAMP,
  559    559   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_DESTINATION_CONFIG,
  560    560   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_RECORD_AGE_IN_SECONDS,
  561    561   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_BISECT_BATCH_ON_FUNCTION_ERROR,
  562    562   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_RETRY_ATTEMPTS,
  563    563   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_TAGS,
  564    564   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_TUMBLING_WINDOW_IN_SECONDS,
  565    565   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_TOPICS,
  566    566   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_QUEUES,
  567    567   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_SOURCE_ACCESS_CONFIGURATIONS,
  568    568   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_SELF_MANAGED_EVENT_SOURCE,
  569    569   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_FUNCTION_RESPONSE_TYPES,
  570    570   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_AMAZON_MANAGED_KAFKA_EVENT_SOURCE_CONFIG,
  571    571   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_SELF_MANAGED_KAFKA_EVENT_SOURCE_CONFIG,
  572    572   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_SCALING_CONFIG,
  573    573   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_DOCUMENT_DB_EVENT_SOURCE_CONFIG,
  574    574   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_KMS_KEY_ARN,
  575    575   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_METRICS_CONFIG,
  576    576   
        &CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_PROVISIONED_POLLER_CONFIG,
  577    577   
    ],
  578         -
);
         578  +
)
         579  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
         580  +
    "POST",
         581  +
    "/2015-03-31/event-source-mappings",
         582  +
    Some(202),
         583  +
));
  579    584   
impl CreateEventSourceMappingInput {
  580    585   
    /// The schema for this shape.
  581    586   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEEVENTSOURCEMAPPINGINPUT_SCHEMA;
  582    587   
}
  583    588   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateEventSourceMappingInput {
  584    589   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  585    590   
    fn serialize_members(
  586    591   
        &self,
  587    592   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  588    593   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
@@ -686,691 +899,880 @@
  706    711   
            ser.write_struct(&CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_METRICS_CONFIG, val)?;
  707    712   
        }
  708    713   
        if let Some(ref val) = self.provisioned_poller_config {
  709    714   
            ser.write_struct(&CREATEEVENTSOURCEMAPPINGINPUT_MEMBER_PROVISIONED_POLLER_CONFIG, val)?;
  710    715   
        }
  711    716   
        Ok(())
  712    717   
    }
  713    718   
}
  714    719   
impl CreateEventSourceMappingInput {
  715    720   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  716         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  717         -
        deserializer: &mut D,
         721  +
    pub fn deserialize(
         722  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  718    723   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  719    724   
        #[allow(unused_variables, unused_mut)]
  720    725   
        let mut builder = Self::builder();
  721    726   
        #[allow(
  722    727   
            unused_variables,
  723    728   
            unreachable_code,
  724    729   
            clippy::single_match,
  725    730   
            clippy::match_single_binding,
  726    731   
            clippy::diverging_sub_expression
  727    732   
        )]
  728         -
        deserializer.read_struct(&CREATEEVENTSOURCEMAPPINGINPUT_SCHEMA, (), |_, member, deser| {
         733  +
        deserializer.read_struct(&CREATEEVENTSOURCEMAPPINGINPUT_SCHEMA, &mut |member, deser| {
  729    734   
            match member.member_index() {
  730    735   
                Some(0) => {
  731    736   
                    builder.event_source_arn = Some(deser.read_string(member)?);
  732    737   
                }
  733    738   
                Some(1) => {
  734    739   
                    builder.function_name = Some(deser.read_string(member)?);
  735    740   
                }
  736    741   
                Some(2) => {
  737    742   
                    builder.enabled = Some(deser.read_boolean(member)?);
  738    743   
                }
  739    744   
                Some(3) => {
  740    745   
                    builder.batch_size = Some(deser.read_integer(member)?);
  741    746   
                }
  742    747   
                Some(4) => {
  743    748   
                    builder.filter_criteria = Some(crate::types::FilterCriteria::deserialize(deser)?);
  744    749   
                }
  745    750   
                Some(5) => {
  746    751   
                    builder.maximum_batching_window_in_seconds = Some(deser.read_integer(member)?);
  747    752   
                }
  748    753   
                Some(6) => {
  749    754   
                    builder.parallelization_factor = Some(deser.read_integer(member)?);
  750    755   
                }
  751    756   
                Some(7) => {
  752    757   
                    builder.starting_position = Some(crate::types::EventSourcePosition::from(deser.read_string(member)?.as_str()));
  753    758   
                }
  754    759   
                Some(8) => {
  755    760   
                    builder.starting_position_timestamp = Some(deser.read_timestamp(member)?);
  756    761   
                }
  757    762   
                Some(9) => {
  758    763   
                    builder.destination_config = Some(crate::types::DestinationConfig::deserialize(deser)?);
  759    764   
                }
  760    765   
                Some(10) => {
  761    766   
                    builder.maximum_record_age_in_seconds = Some(deser.read_integer(member)?);
  762    767   
                }
  763    768   
                Some(11) => {
  764    769   
                    builder.bisect_batch_on_function_error = Some(deser.read_boolean(member)?);
  765    770   
                }
  766    771   
                Some(12) => {
  767    772   
                    builder.maximum_retry_attempts = Some(deser.read_integer(member)?);
  768    773   
                }
  769    774   
                Some(13) => {
  770         -
                    builder.tags = Some({
  771         -
                        let container = if let Some(cap) = deser.container_size() {
  772         -
                            std::collections::HashMap::with_capacity(cap)
  773         -
                        } else {
  774         -
                            std::collections::HashMap::new()
  775         -
                        };
  776         -
                        deser.read_map(member, container, |mut map, key, deser| {
  777         -
                            map.insert(key, deser.read_string(member)?);
  778         -
                            Ok(map)
  779         -
                        })?
  780         -
                    });
         775  +
                    builder.tags = Some(deser.read_string_string_map(member)?);
  781    776   
                }
  782    777   
                Some(14) => {
  783    778   
                    builder.tumbling_window_in_seconds = Some(deser.read_integer(member)?);
  784    779   
                }
  785    780   
                Some(15) => {
  786         -
                    builder.topics = Some({
  787         -
                        let container = if let Some(cap) = deser.container_size() {
  788         -
                            Vec::with_capacity(cap)
  789         -
                        } else {
  790         -
                            Vec::new()
  791         -
                        };
  792         -
                        deser.read_list(member, container, |mut list, deser| {
  793         -
                            list.push(deser.read_string(member)?);
  794         -
                            Ok(list)
  795         -
                        })?
  796         -
                    });
         781  +
                    builder.topics = Some(deser.read_string_list(member)?);
  797    782   
                }
  798    783   
                Some(16) => {
  799         -
                    builder.queues = Some({
  800         -
                        let container = if let Some(cap) = deser.container_size() {
  801         -
                            Vec::with_capacity(cap)
  802         -
                        } else {
  803         -
                            Vec::new()
  804         -
                        };
  805         -
                        deser.read_list(member, container, |mut list, deser| {
  806         -
                            list.push(deser.read_string(member)?);
  807         -
                            Ok(list)
  808         -
                        })?
  809         -
                    });
         784  +
                    builder.queues = Some(deser.read_string_list(member)?);
  810    785   
                }
  811    786   
                Some(17) => {
  812    787   
                    builder.source_access_configurations = Some({
  813         -
                        let container = if let Some(cap) = deser.container_size() {
  814         -
                            Vec::with_capacity(cap)
  815         -
                        } else {
  816         -
                            Vec::new()
  817         -
                        };
  818         -
                        deser.read_list(member, container, |mut list, deser| {
  819         -
                            list.push(crate::types::SourceAccessConfiguration::deserialize(deser)?);
  820         -
                            Ok(list)
  821         -
                        })?
         788  +
                        let mut container = Vec::new();
         789  +
                        deser.read_list(member, &mut |deser| {
         790  +
                            container.push(crate::types::SourceAccessConfiguration::deserialize(deser)?);
         791  +
                            Ok(())
         792  +
                        })?;
         793  +
                        container
  822    794   
                    });
  823    795   
                }
  824    796   
                Some(18) => {
  825    797   
                    builder.self_managed_event_source = Some(crate::types::SelfManagedEventSource::deserialize(deser)?);
  826    798   
                }
  827    799   
                Some(19) => {
  828    800   
                    builder.function_response_types = Some({
  829         -
                        let container = if let Some(cap) = deser.container_size() {
  830         -
                            Vec::with_capacity(cap)
  831         -
                        } else {
  832         -
                            Vec::new()
  833         -
                        };
  834         -
                        deser.read_list(member, container, |mut list, deser| {
  835         -
                            list.push(crate::types::FunctionResponseType::from(deser.read_string(member)?.as_str()));
  836         -
                            Ok(list)
  837         -
                        })?
         801  +
                        let mut container = Vec::new();
         802  +
                        deser.read_list(member, &mut |deser| {
         803  +
                            container.push(crate::types::FunctionResponseType::from(deser.read_string(member)?.as_str()));
         804  +
                            Ok(())
         805  +
                        })?;
         806  +
                        container
  838    807   
                    });
  839    808   
                }
  840    809   
                Some(20) => {
  841    810   
                    builder.amazon_managed_kafka_event_source_config = Some(crate::types::AmazonManagedKafkaEventSourceConfig::deserialize(deser)?);
  842    811   
                }
  843    812   
                Some(21) => {
  844    813   
                    builder.self_managed_kafka_event_source_config = Some(crate::types::SelfManagedKafkaEventSourceConfig::deserialize(deser)?);
  845    814   
                }
  846    815   
                Some(22) => {
  847    816   
                    builder.scaling_config = Some(crate::types::ScalingConfig::deserialize(deser)?);
  848    817   
                }
  849    818   
                Some(23) => {
  850    819   
                    builder.document_db_event_source_config = Some(crate::types::DocumentDbEventSourceConfig::deserialize(deser)?);
  851    820   
                }
  852    821   
                Some(24) => {
  853    822   
                    builder.kms_key_arn = Some(deser.read_string(member)?);
  854    823   
                }
  855    824   
                Some(25) => {
  856    825   
                    builder.metrics_config = Some(crate::types::EventSourceMappingMetricsConfig::deserialize(deser)?);
  857    826   
                }
  858    827   
                Some(26) => {
  859    828   
                    builder.provisioned_poller_config = Some(crate::types::ProvisionedPollerConfig::deserialize(deser)?);
  860    829   
                }
  861    830   
                _ => {}
  862    831   
            }
  863    832   
            Ok(())
  864    833   
        })?;
         834  +
        builder.function_name = builder.function_name.or(Some(String::new()));
  865    835   
        builder
  866    836   
            .build()
  867    837   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  868    838   
    }
  869    839   
}
         840  +
impl CreateEventSourceMappingInput {
         841  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         842  +
    pub fn deserialize_with_response(
         843  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         844  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         845  +
        _status: u16,
         846  +
        _body: &[u8],
         847  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         848  +
        Self::deserialize(deserializer)
         849  +
    }
         850  +
}
  870    851   
impl CreateEventSourceMappingInput {
  871    852   
    /// Creates a new builder-style object to manufacture [`CreateEventSourceMappingInput`](crate::operation::create_event_source_mapping::CreateEventSourceMappingInput).
  872    853   
    pub fn builder() -> crate::operation::create_event_source_mapping::builders::CreateEventSourceMappingInputBuilder {
  873    854   
        crate::operation::create_event_source_mapping::builders::CreateEventSourceMappingInputBuilder::default()
  874    855   
    }
  875    856   
}
  876    857   
  877    858   
/// A builder for [`CreateEventSourceMappingInput`](crate::operation::create_event_source_mapping::CreateEventSourceMappingInput).
  878    859   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  879    860   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/create_event_source_mapping/_create_event_source_mapping_output.rs

@@ -207,207 +618,626 @@
  227    227   
    "com.amazonaws.lambda.synthetic",
  228    228   
    "CreateEventSourceMappingOutput",
  229    229   
);
  230    230   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_UUID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  231    231   
    ::aws_smithy_schema::ShapeId::from_static(
  232    232   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$UUID",
  233    233   
        "com.amazonaws.lambda.synthetic",
  234    234   
        "CreateEventSourceMappingOutput",
  235    235   
    ),
  236    236   
    ::aws_smithy_schema::ShapeType::String,
  237         -
    "uuid",
         237  +
    "UUID",
  238    238   
    0,
  239    239   
);
  240    240   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STARTING_POSITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  241    241   
    ::aws_smithy_schema::ShapeId::from_static(
  242    242   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$StartingPosition",
  243    243   
        "com.amazonaws.lambda.synthetic",
  244    244   
        "CreateEventSourceMappingOutput",
  245    245   
    ),
  246    246   
    ::aws_smithy_schema::ShapeType::String,
  247         -
    "starting_position",
         247  +
    "StartingPosition",
  248    248   
    1,
  249    249   
);
  250    250   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STARTING_POSITION_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  251    251   
    ::aws_smithy_schema::ShapeId::from_static(
  252    252   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$StartingPositionTimestamp",
  253    253   
        "com.amazonaws.lambda.synthetic",
  254    254   
        "CreateEventSourceMappingOutput",
  255    255   
    ),
  256    256   
    ::aws_smithy_schema::ShapeType::Timestamp,
  257         -
    "starting_position_timestamp",
         257  +
    "StartingPositionTimestamp",
  258    258   
    2,
  259    259   
);
  260    260   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_BATCH_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  261    261   
    ::aws_smithy_schema::ShapeId::from_static(
  262    262   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$BatchSize",
  263    263   
        "com.amazonaws.lambda.synthetic",
  264    264   
        "CreateEventSourceMappingOutput",
  265    265   
    ),
  266    266   
    ::aws_smithy_schema::ShapeType::Integer,
  267         -
    "batch_size",
         267  +
    "BatchSize",
  268    268   
    3,
  269    269   
);
  270    270   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_MAXIMUM_BATCHING_WINDOW_IN_SECONDS: ::aws_smithy_schema::Schema =
  271    271   
    ::aws_smithy_schema::Schema::new_member(
  272    272   
        ::aws_smithy_schema::ShapeId::from_static(
  273    273   
            "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$MaximumBatchingWindowInSeconds",
  274    274   
            "com.amazonaws.lambda.synthetic",
  275    275   
            "CreateEventSourceMappingOutput",
  276    276   
        ),
  277    277   
        ::aws_smithy_schema::ShapeType::Integer,
  278         -
        "maximum_batching_window_in_seconds",
         278  +
        "MaximumBatchingWindowInSeconds",
  279    279   
        4,
  280    280   
    );
  281    281   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_PARALLELIZATION_FACTOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  282    282   
    ::aws_smithy_schema::ShapeId::from_static(
  283    283   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$ParallelizationFactor",
  284    284   
        "com.amazonaws.lambda.synthetic",
  285    285   
        "CreateEventSourceMappingOutput",
  286    286   
    ),
  287    287   
    ::aws_smithy_schema::ShapeType::Integer,
  288         -
    "parallelization_factor",
         288  +
    "ParallelizationFactor",
  289    289   
    5,
  290    290   
);
  291    291   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_EVENT_SOURCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  292    292   
    ::aws_smithy_schema::ShapeId::from_static(
  293    293   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$EventSourceArn",
  294    294   
        "com.amazonaws.lambda.synthetic",
  295    295   
        "CreateEventSourceMappingOutput",
  296    296   
    ),
  297    297   
    ::aws_smithy_schema::ShapeType::String,
  298         -
    "event_source_arn",
         298  +
    "EventSourceArn",
  299    299   
    6,
  300    300   
);
  301    301   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FILTER_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  302    302   
    ::aws_smithy_schema::ShapeId::from_static(
  303    303   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$FilterCriteria",
  304    304   
        "com.amazonaws.lambda.synthetic",
  305    305   
        "CreateEventSourceMappingOutput",
  306    306   
    ),
  307    307   
    ::aws_smithy_schema::ShapeType::Structure,
  308         -
    "filter_criteria",
         308  +
    "FilterCriteria",
  309    309   
    7,
  310    310   
);
  311    311   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FUNCTION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  312    312   
    ::aws_smithy_schema::ShapeId::from_static(
  313    313   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$FunctionArn",
  314    314   
        "com.amazonaws.lambda.synthetic",
  315    315   
        "CreateEventSourceMappingOutput",
  316    316   
    ),
  317    317   
    ::aws_smithy_schema::ShapeType::String,
  318         -
    "function_arn",
         318  +
    "FunctionArn",
  319    319   
    8,
  320    320   
);
  321    321   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  322    322   
    ::aws_smithy_schema::ShapeId::from_static(
  323    323   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$LastModified",
  324    324   
        "com.amazonaws.lambda.synthetic",
  325    325   
        "CreateEventSourceMappingOutput",
  326    326   
    ),
  327    327   
    ::aws_smithy_schema::ShapeType::Timestamp,
  328         -
    "last_modified",
         328  +
    "LastModified",
  329    329   
    9,
  330    330   
);
  331    331   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_LAST_PROCESSING_RESULT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  332    332   
    ::aws_smithy_schema::ShapeId::from_static(
  333    333   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$LastProcessingResult",
  334    334   
        "com.amazonaws.lambda.synthetic",
  335    335   
        "CreateEventSourceMappingOutput",
  336    336   
    ),
  337    337   
    ::aws_smithy_schema::ShapeType::String,
  338         -
    "last_processing_result",
         338  +
    "LastProcessingResult",
  339    339   
    10,
  340    340   
);
  341    341   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  342    342   
    ::aws_smithy_schema::ShapeId::from_static(
  343    343   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$State",
  344    344   
        "com.amazonaws.lambda.synthetic",
  345    345   
        "CreateEventSourceMappingOutput",
  346    346   
    ),
  347    347   
    ::aws_smithy_schema::ShapeType::String,
  348         -
    "state",
         348  +
    "State",
  349    349   
    11,
  350    350   
);
  351    351   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STATE_TRANSITION_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  352    352   
    ::aws_smithy_schema::ShapeId::from_static(
  353    353   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$StateTransitionReason",
  354    354   
        "com.amazonaws.lambda.synthetic",
  355    355   
        "CreateEventSourceMappingOutput",
  356    356   
    ),
  357    357   
    ::aws_smithy_schema::ShapeType::String,
  358         -
    "state_transition_reason",
         358  +
    "StateTransitionReason",
  359    359   
    12,
  360    360   
);
  361    361   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_DESTINATION_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  362    362   
    ::aws_smithy_schema::ShapeId::from_static(
  363    363   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$DestinationConfig",
  364    364   
        "com.amazonaws.lambda.synthetic",
  365    365   
        "CreateEventSourceMappingOutput",
  366    366   
    ),
  367    367   
    ::aws_smithy_schema::ShapeType::Structure,
  368         -
    "destination_config",
         368  +
    "DestinationConfig",
  369    369   
    13,
  370    370   
);
  371    371   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_TOPICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  372    372   
    ::aws_smithy_schema::ShapeId::from_static(
  373    373   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$Topics",
  374    374   
        "com.amazonaws.lambda.synthetic",
  375    375   
        "CreateEventSourceMappingOutput",
  376    376   
    ),
  377    377   
    ::aws_smithy_schema::ShapeType::List,
  378         -
    "topics",
         378  +
    "Topics",
  379    379   
    14,
  380    380   
);
  381    381   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_QUEUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  382    382   
    ::aws_smithy_schema::ShapeId::from_static(
  383    383   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$Queues",
  384    384   
        "com.amazonaws.lambda.synthetic",
  385    385   
        "CreateEventSourceMappingOutput",
  386    386   
    ),
  387    387   
    ::aws_smithy_schema::ShapeType::List,
  388         -
    "queues",
         388  +
    "Queues",
  389    389   
    15,
  390    390   
);
  391    391   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SOURCE_ACCESS_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  392    392   
    ::aws_smithy_schema::ShapeId::from_static(
  393    393   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$SourceAccessConfigurations",
  394    394   
        "com.amazonaws.lambda.synthetic",
  395    395   
        "CreateEventSourceMappingOutput",
  396    396   
    ),
  397    397   
    ::aws_smithy_schema::ShapeType::List,
  398         -
    "source_access_configurations",
         398  +
    "SourceAccessConfigurations",
  399    399   
    16,
  400    400   
);
  401    401   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SELF_MANAGED_EVENT_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  402    402   
    ::aws_smithy_schema::ShapeId::from_static(
  403    403   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$SelfManagedEventSource",
  404    404   
        "com.amazonaws.lambda.synthetic",
  405    405   
        "CreateEventSourceMappingOutput",
  406    406   
    ),
  407    407   
    ::aws_smithy_schema::ShapeType::Structure,
  408         -
    "self_managed_event_source",
         408  +
    "SelfManagedEventSource",
  409    409   
    17,
  410    410   
);
  411    411   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_MAXIMUM_RECORD_AGE_IN_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  412    412   
    ::aws_smithy_schema::ShapeId::from_static(
  413    413   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$MaximumRecordAgeInSeconds",
  414    414   
        "com.amazonaws.lambda.synthetic",
  415    415   
        "CreateEventSourceMappingOutput",
  416    416   
    ),
  417    417   
    ::aws_smithy_schema::ShapeType::Integer,
  418         -
    "maximum_record_age_in_seconds",
         418  +
    "MaximumRecordAgeInSeconds",
  419    419   
    18,
  420    420   
);
  421    421   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_BISECT_BATCH_ON_FUNCTION_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  422    422   
    ::aws_smithy_schema::ShapeId::from_static(
  423    423   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$BisectBatchOnFunctionError",
  424    424   
        "com.amazonaws.lambda.synthetic",
  425    425   
        "CreateEventSourceMappingOutput",
  426    426   
    ),
  427    427   
    ::aws_smithy_schema::ShapeType::Boolean,
  428         -
    "bisect_batch_on_function_error",
         428  +
    "BisectBatchOnFunctionError",
  429    429   
    19,
  430    430   
);
  431    431   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_MAXIMUM_RETRY_ATTEMPTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  432    432   
    ::aws_smithy_schema::ShapeId::from_static(
  433    433   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$MaximumRetryAttempts",
  434    434   
        "com.amazonaws.lambda.synthetic",
  435    435   
        "CreateEventSourceMappingOutput",
  436    436   
    ),
  437    437   
    ::aws_smithy_schema::ShapeType::Integer,
  438         -
    "maximum_retry_attempts",
         438  +
    "MaximumRetryAttempts",
  439    439   
    20,
  440    440   
);
  441    441   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_TUMBLING_WINDOW_IN_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  442    442   
    ::aws_smithy_schema::ShapeId::from_static(
  443    443   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$TumblingWindowInSeconds",
  444    444   
        "com.amazonaws.lambda.synthetic",
  445    445   
        "CreateEventSourceMappingOutput",
  446    446   
    ),
  447    447   
    ::aws_smithy_schema::ShapeType::Integer,
  448         -
    "tumbling_window_in_seconds",
         448  +
    "TumblingWindowInSeconds",
  449    449   
    21,
  450    450   
);
  451    451   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FUNCTION_RESPONSE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  452    452   
    ::aws_smithy_schema::ShapeId::from_static(
  453    453   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$FunctionResponseTypes",
  454    454   
        "com.amazonaws.lambda.synthetic",
  455    455   
        "CreateEventSourceMappingOutput",
  456    456   
    ),
  457    457   
    ::aws_smithy_schema::ShapeType::List,
  458         -
    "function_response_types",
         458  +
    "FunctionResponseTypes",
  459    459   
    22,
  460    460   
);
  461    461   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_AMAZON_MANAGED_KAFKA_EVENT_SOURCE_CONFIG: ::aws_smithy_schema::Schema =
  462    462   
    ::aws_smithy_schema::Schema::new_member(
  463    463   
        ::aws_smithy_schema::ShapeId::from_static(
  464    464   
            "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$AmazonManagedKafkaEventSourceConfig",
  465    465   
            "com.amazonaws.lambda.synthetic",
  466    466   
            "CreateEventSourceMappingOutput",
  467    467   
        ),
  468    468   
        ::aws_smithy_schema::ShapeType::Structure,
  469         -
        "amazon_managed_kafka_event_source_config",
         469  +
        "AmazonManagedKafkaEventSourceConfig",
  470    470   
        23,
  471    471   
    );
  472    472   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SELF_MANAGED_KAFKA_EVENT_SOURCE_CONFIG: ::aws_smithy_schema::Schema =
  473    473   
    ::aws_smithy_schema::Schema::new_member(
  474    474   
        ::aws_smithy_schema::ShapeId::from_static(
  475    475   
            "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$SelfManagedKafkaEventSourceConfig",
  476    476   
            "com.amazonaws.lambda.synthetic",
  477    477   
            "CreateEventSourceMappingOutput",
  478    478   
        ),
  479    479   
        ::aws_smithy_schema::ShapeType::Structure,
  480         -
        "self_managed_kafka_event_source_config",
         480  +
        "SelfManagedKafkaEventSourceConfig",
  481    481   
        24,
  482    482   
    );
  483    483   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SCALING_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  484    484   
    ::aws_smithy_schema::ShapeId::from_static(
  485    485   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$ScalingConfig",
  486    486   
        "com.amazonaws.lambda.synthetic",
  487    487   
        "CreateEventSourceMappingOutput",
  488    488   
    ),
  489    489   
    ::aws_smithy_schema::ShapeType::Structure,
  490         -
    "scaling_config",
         490  +
    "ScalingConfig",
  491    491   
    25,
  492    492   
);
  493    493   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_DOCUMENT_DB_EVENT_SOURCE_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  494    494   
    ::aws_smithy_schema::ShapeId::from_static(
  495    495   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$DocumentDBEventSourceConfig",
  496    496   
        "com.amazonaws.lambda.synthetic",
  497    497   
        "CreateEventSourceMappingOutput",
  498    498   
    ),
  499    499   
    ::aws_smithy_schema::ShapeType::Structure,
  500         -
    "document_db_event_source_config",
         500  +
    "DocumentDBEventSourceConfig",
  501    501   
    26,
  502    502   
);
  503    503   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_KMS_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  504    504   
    ::aws_smithy_schema::ShapeId::from_static(
  505    505   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$KMSKeyArn",
  506    506   
        "com.amazonaws.lambda.synthetic",
  507    507   
        "CreateEventSourceMappingOutput",
  508    508   
    ),
  509    509   
    ::aws_smithy_schema::ShapeType::String,
  510         -
    "kms_key_arn",
         510  +
    "KMSKeyArn",
  511    511   
    27,
  512    512   
);
  513    513   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FILTER_CRITERIA_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  514    514   
    ::aws_smithy_schema::ShapeId::from_static(
  515    515   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$FilterCriteriaError",
  516    516   
        "com.amazonaws.lambda.synthetic",
  517    517   
        "CreateEventSourceMappingOutput",
  518    518   
    ),
  519    519   
    ::aws_smithy_schema::ShapeType::Structure,
  520         -
    "filter_criteria_error",
         520  +
    "FilterCriteriaError",
  521    521   
    28,
  522    522   
);
  523    523   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_EVENT_SOURCE_MAPPING_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  524    524   
    ::aws_smithy_schema::ShapeId::from_static(
  525    525   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$EventSourceMappingArn",
  526    526   
        "com.amazonaws.lambda.synthetic",
  527    527   
        "CreateEventSourceMappingOutput",
  528    528   
    ),
  529    529   
    ::aws_smithy_schema::ShapeType::String,
  530         -
    "event_source_mapping_arn",
         530  +
    "EventSourceMappingArn",
  531    531   
    29,
  532    532   
);
  533    533   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_METRICS_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  534    534   
    ::aws_smithy_schema::ShapeId::from_static(
  535    535   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$MetricsConfig",
  536    536   
        "com.amazonaws.lambda.synthetic",
  537    537   
        "CreateEventSourceMappingOutput",
  538    538   
    ),
  539    539   
    ::aws_smithy_schema::ShapeType::Structure,
  540         -
    "metrics_config",
         540  +
    "MetricsConfig",
  541    541   
    30,
  542    542   
);
  543    543   
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_PROVISIONED_POLLER_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  544    544   
    ::aws_smithy_schema::ShapeId::from_static(
  545    545   
        "com.amazonaws.lambda.synthetic#CreateEventSourceMappingOutput$ProvisionedPollerConfig",
  546    546   
        "com.amazonaws.lambda.synthetic",
  547    547   
        "CreateEventSourceMappingOutput",
  548    548   
    ),
  549    549   
    ::aws_smithy_schema::ShapeType::Structure,
  550         -
    "provisioned_poller_config",
         550  +
    "ProvisionedPollerConfig",
  551    551   
    31,
  552    552   
);
         553  +
static CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         554  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         555  +
    ::aws_smithy_schema::ShapeType::String,
         556  +
    "request_id",
         557  +
    32,
         558  +
)
         559  +
.with_http_header("x-amzn-requestid");
  553    560   
static CREATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  554    561   
    CREATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA_ID,
  555    562   
    ::aws_smithy_schema::ShapeType::Structure,
  556    563   
    &[
  557    564   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_UUID,
  558    565   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STARTING_POSITION,
  559    566   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STARTING_POSITION_TIMESTAMP,
  560    567   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_BATCH_SIZE,
  561    568   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_MAXIMUM_BATCHING_WINDOW_IN_SECONDS,
  562    569   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_PARALLELIZATION_FACTOR,
  563    570   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_EVENT_SOURCE_ARN,
  564    571   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FILTER_CRITERIA,
  565    572   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FUNCTION_ARN,
  566    573   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_LAST_MODIFIED,
  567    574   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_LAST_PROCESSING_RESULT,
  568    575   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STATE,
  569    576   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STATE_TRANSITION_REASON,
  570    577   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_DESTINATION_CONFIG,
  571    578   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_TOPICS,
  572    579   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_QUEUES,
  573    580   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SOURCE_ACCESS_CONFIGURATIONS,
  574    581   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SELF_MANAGED_EVENT_SOURCE,
  575    582   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_MAXIMUM_RECORD_AGE_IN_SECONDS,
  576    583   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_BISECT_BATCH_ON_FUNCTION_ERROR,
  577    584   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_MAXIMUM_RETRY_ATTEMPTS,
  578    585   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_TUMBLING_WINDOW_IN_SECONDS,
  579    586   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FUNCTION_RESPONSE_TYPES,
  580    587   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_AMAZON_MANAGED_KAFKA_EVENT_SOURCE_CONFIG,
  581    588   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SELF_MANAGED_KAFKA_EVENT_SOURCE_CONFIG,
  582    589   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SCALING_CONFIG,
  583    590   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_DOCUMENT_DB_EVENT_SOURCE_CONFIG,
  584    591   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_KMS_KEY_ARN,
  585    592   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FILTER_CRITERIA_ERROR,
  586    593   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_EVENT_SOURCE_MAPPING_ARN,
  587    594   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_METRICS_CONFIG,
  588    595   
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_PROVISIONED_POLLER_CONFIG,
         596  +
        &CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER__REQUEST_ID,
  589    597   
    ],
  590    598   
);
  591    599   
impl CreateEventSourceMappingOutput {
  592    600   
    /// The schema for this shape.
  593    601   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA;
  594    602   
}
  595    603   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateEventSourceMappingOutput {
  596    604   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  597    605   
    fn serialize_members(
  598    606   
        &self,
@@ -704,712 +884,1010 @@
  724    732   
            ser.write_struct(&CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_METRICS_CONFIG, val)?;
  725    733   
        }
  726    734   
        if let Some(ref val) = self.provisioned_poller_config {
  727    735   
            ser.write_struct(&CREATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_PROVISIONED_POLLER_CONFIG, val)?;
  728    736   
        }
  729    737   
        Ok(())
  730    738   
    }
  731    739   
}
  732    740   
impl CreateEventSourceMappingOutput {
  733    741   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  734         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  735         -
        deserializer: &mut D,
         742  +
    pub fn deserialize(
         743  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  736    744   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  737    745   
        #[allow(unused_variables, unused_mut)]
  738    746   
        let mut builder = Self::builder();
  739    747   
        #[allow(
  740    748   
            unused_variables,
  741    749   
            unreachable_code,
  742    750   
            clippy::single_match,
  743    751   
            clippy::match_single_binding,
  744    752   
            clippy::diverging_sub_expression
  745    753   
        )]
  746         -
        deserializer.read_struct(&CREATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA, (), |_, member, deser| {
         754  +
        deserializer.read_struct(&CREATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA, &mut |member, deser| {
  747    755   
            match member.member_index() {
  748    756   
                Some(0) => {
  749    757   
                    builder.uuid = Some(deser.read_string(member)?);
  750    758   
                }
  751    759   
                Some(1) => {
  752    760   
                    builder.starting_position = Some(crate::types::EventSourcePosition::from(deser.read_string(member)?.as_str()));
  753    761   
                }
  754    762   
                Some(2) => {
  755    763   
                    builder.starting_position_timestamp = Some(deser.read_timestamp(member)?);
  756    764   
                }
  757    765   
                Some(3) => {
  758    766   
                    builder.batch_size = Some(deser.read_integer(member)?);
  759    767   
                }
  760    768   
                Some(4) => {
  761    769   
                    builder.maximum_batching_window_in_seconds = Some(deser.read_integer(member)?);
  762    770   
                }
  763    771   
                Some(5) => {
  764    772   
                    builder.parallelization_factor = Some(deser.read_integer(member)?);
  765    773   
                }
  766    774   
                Some(6) => {
  767    775   
                    builder.event_source_arn = Some(deser.read_string(member)?);
  768    776   
                }
  769    777   
                Some(7) => {
  770    778   
                    builder.filter_criteria = Some(crate::types::FilterCriteria::deserialize(deser)?);
  771    779   
                }
  772    780   
                Some(8) => {
  773    781   
                    builder.function_arn = Some(deser.read_string(member)?);
  774    782   
                }
  775    783   
                Some(9) => {
  776    784   
                    builder.last_modified = Some(deser.read_timestamp(member)?);
  777    785   
                }
  778    786   
                Some(10) => {
  779    787   
                    builder.last_processing_result = Some(deser.read_string(member)?);
  780    788   
                }
  781    789   
                Some(11) => {
  782    790   
                    builder.state = Some(deser.read_string(member)?);
  783    791   
                }
  784    792   
                Some(12) => {
  785    793   
                    builder.state_transition_reason = Some(deser.read_string(member)?);
  786    794   
                }
  787    795   
                Some(13) => {
  788    796   
                    builder.destination_config = Some(crate::types::DestinationConfig::deserialize(deser)?);
  789    797   
                }
  790    798   
                Some(14) => {
  791         -
                    builder.topics = Some({
  792         -
                        let container = if let Some(cap) = deser.container_size() {
  793         -
                            Vec::with_capacity(cap)
  794         -
                        } else {
  795         -
                            Vec::new()
  796         -
                        };
  797         -
                        deser.read_list(member, container, |mut list, deser| {
  798         -
                            list.push(deser.read_string(member)?);
  799         -
                            Ok(list)
  800         -
                        })?
  801         -
                    });
         799  +
                    builder.topics = Some(deser.read_string_list(member)?);
  802    800   
                }
  803    801   
                Some(15) => {
  804         -
                    builder.queues = Some({
  805         -
                        let container = if let Some(cap) = deser.container_size() {
  806         -
                            Vec::with_capacity(cap)
  807         -
                        } else {
  808         -
                            Vec::new()
  809         -
                        };
  810         -
                        deser.read_list(member, container, |mut list, deser| {
  811         -
                            list.push(deser.read_string(member)?);
  812         -
                            Ok(list)
  813         -
                        })?
         802  +
                    builder.queues = Some(deser.read_string_list(member)?);
         803  +
                }
         804  +
                Some(16) => {
         805  +
                    builder.source_access_configurations = Some({
         806  +
                        let mut container = Vec::new();
         807  +
                        deser.read_list(member, &mut |deser| {
         808  +
                            container.push(crate::types::SourceAccessConfiguration::deserialize(deser)?);
         809  +
                            Ok(())
         810  +
                        })?;
         811  +
                        container
         812  +
                    });
         813  +
                }
         814  +
                Some(17) => {
         815  +
                    builder.self_managed_event_source = Some(crate::types::SelfManagedEventSource::deserialize(deser)?);
         816  +
                }
         817  +
                Some(18) => {
         818  +
                    builder.maximum_record_age_in_seconds = Some(deser.read_integer(member)?);
         819  +
                }
         820  +
                Some(19) => {
         821  +
                    builder.bisect_batch_on_function_error = Some(deser.read_boolean(member)?);
         822  +
                }
         823  +
                Some(20) => {
         824  +
                    builder.maximum_retry_attempts = Some(deser.read_integer(member)?);
         825  +
                }
         826  +
                Some(21) => {
         827  +
                    builder.tumbling_window_in_seconds = Some(deser.read_integer(member)?);
         828  +
                }
         829  +
                Some(22) => {
         830  +
                    builder.function_response_types = Some({
         831  +
                        let mut container = Vec::new();
         832  +
                        deser.read_list(member, &mut |deser| {
         833  +
                            container.push(crate::types::FunctionResponseType::from(deser.read_string(member)?.as_str()));
         834  +
                            Ok(())
         835  +
                        })?;
         836  +
                        container
  814    837   
                    });
  815    838   
                }
         839  +
                Some(23) => {
         840  +
                    builder.amazon_managed_kafka_event_source_config = Some(crate::types::AmazonManagedKafkaEventSourceConfig::deserialize(deser)?);
         841  +
                }
         842  +
                Some(24) => {
         843  +
                    builder.self_managed_kafka_event_source_config = Some(crate::types::SelfManagedKafkaEventSourceConfig::deserialize(deser)?);
         844  +
                }
         845  +
                Some(25) => {
         846  +
                    builder.scaling_config = Some(crate::types::ScalingConfig::deserialize(deser)?);
         847  +
                }
         848  +
                Some(26) => {
         849  +
                    builder.document_db_event_source_config = Some(crate::types::DocumentDbEventSourceConfig::deserialize(deser)?);
         850  +
                }
         851  +
                Some(27) => {
         852  +
                    builder.kms_key_arn = Some(deser.read_string(member)?);
         853  +
                }
         854  +
                Some(28) => {
         855  +
                    builder.filter_criteria_error = Some(crate::types::FilterCriteriaError::deserialize(deser)?);
         856  +
                }
         857  +
                Some(29) => {
         858  +
                    builder.event_source_mapping_arn = Some(deser.read_string(member)?);
         859  +
                }
         860  +
                Some(30) => {
         861  +
                    builder.metrics_config = Some(crate::types::EventSourceMappingMetricsConfig::deserialize(deser)?);
         862  +
                }
         863  +
                Some(31) => {
         864  +
                    builder.provisioned_poller_config = Some(crate::types::ProvisionedPollerConfig::deserialize(deser)?);
         865  +
                }
         866  +
                Some(32) => {
         867  +
                    builder._request_id = Some(deser.read_string(member)?);
         868  +
                }
         869  +
                _ => {}
         870  +
            }
         871  +
            Ok(())
         872  +
        })?;
         873  +
        Ok(builder.build())
         874  +
    }
         875  +
}
         876  +
impl CreateEventSourceMappingOutput {
         877  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         878  +
    /// Header-bound members are read directly from headers, avoiding runtime
         879  +
    /// member iteration overhead. Body members are read via the deserializer.
         880  +
    pub fn deserialize_with_response(
         881  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         882  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         883  +
        _status: u16,
         884  +
        _body: &[u8],
         885  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         886  +
        #[allow(unused_variables, unused_mut)]
         887  +
        let mut builder = Self::builder();
         888  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         889  +
            builder._request_id = Some(val.to_string());
         890  +
        }
         891  +
        #[allow(
         892  +
            unused_variables,
         893  +
            unreachable_code,
         894  +
            clippy::single_match,
         895  +
            clippy::match_single_binding,
         896  +
            clippy::diverging_sub_expression
         897  +
        )]
         898  +
        deserializer.read_struct(&CREATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA, &mut |member, deser| {
         899  +
            match member.member_index() {
         900  +
                Some(0) => {
         901  +
                    builder.uuid = Some(deser.read_string(member)?);
         902  +
                }
         903  +
                Some(1) => {
         904  +
                    builder.starting_position = Some(crate::types::EventSourcePosition::from(deser.read_string(member)?.as_str()));
         905  +
                }
         906  +
                Some(2) => {
         907  +
                    builder.starting_position_timestamp = Some(deser.read_timestamp(member)?);
         908  +
                }
         909  +
                Some(3) => {
         910  +
                    builder.batch_size = Some(deser.read_integer(member)?);
         911  +
                }
         912  +
                Some(4) => {
         913  +
                    builder.maximum_batching_window_in_seconds = Some(deser.read_integer(member)?);
         914  +
                }
         915  +
                Some(5) => {
         916  +
                    builder.parallelization_factor = Some(deser.read_integer(member)?);
         917  +
                }
         918  +
                Some(6) => {
         919  +
                    builder.event_source_arn = Some(deser.read_string(member)?);
         920  +
                }
         921  +
                Some(7) => {
         922  +
                    builder.filter_criteria = Some(crate::types::FilterCriteria::deserialize(deser)?);
         923  +
                }
         924  +
                Some(8) => {
         925  +
                    builder.function_arn = Some(deser.read_string(member)?);
         926  +
                }
         927  +
                Some(9) => {
         928  +
                    builder.last_modified = Some(deser.read_timestamp(member)?);
         929  +
                }
         930  +
                Some(10) => {
         931  +
                    builder.last_processing_result = Some(deser.read_string(member)?);
         932  +
                }
         933  +
                Some(11) => {
         934  +
                    builder.state = Some(deser.read_string(member)?);
         935  +
                }
         936  +
                Some(12) => {
         937  +
                    builder.state_transition_reason = Some(deser.read_string(member)?);
         938  +
                }
         939  +
                Some(13) => {
         940  +
                    builder.destination_config = Some(crate::types::DestinationConfig::deserialize(deser)?);
         941  +
                }
         942  +
                Some(14) => {
         943  +
                    builder.topics = Some(deser.read_string_list(member)?);
         944  +
                }
         945  +
                Some(15) => {
         946  +
                    builder.queues = Some(deser.read_string_list(member)?);
         947  +
                }
  816    948   
                Some(16) => {
  817    949   
                    builder.source_access_configurations = Some({
  818         -
                        let container = if let Some(cap) = deser.container_size() {
  819         -
                            Vec::with_capacity(cap)
  820         -
                        } else {
  821         -
                            Vec::new()
  822         -
                        };
  823         -
                        deser.read_list(member, container, |mut list, deser| {
  824         -
                            list.push(crate::types::SourceAccessConfiguration::deserialize(deser)?);
  825         -
                            Ok(list)
  826         -
                        })?
         950  +
                        let mut container = Vec::new();
         951  +
                        deser.read_list(member, &mut |deser| {
         952  +
                            container.push(crate::types::SourceAccessConfiguration::deserialize(deser)?);
         953  +
                            Ok(())
         954  +
                        })?;
         955  +
                        container
  827    956   
                    });
  828    957   
                }
  829    958   
                Some(17) => {
  830    959   
                    builder.self_managed_event_source = Some(crate::types::SelfManagedEventSource::deserialize(deser)?);
  831    960   
                }
  832    961   
                Some(18) => {
  833    962   
                    builder.maximum_record_age_in_seconds = Some(deser.read_integer(member)?);
  834    963   
                }
  835    964   
                Some(19) => {
  836    965   
                    builder.bisect_batch_on_function_error = Some(deser.read_boolean(member)?);
  837    966   
                }
  838    967   
                Some(20) => {
  839    968   
                    builder.maximum_retry_attempts = Some(deser.read_integer(member)?);
  840    969   
                }
  841    970   
                Some(21) => {
  842    971   
                    builder.tumbling_window_in_seconds = Some(deser.read_integer(member)?);
  843    972   
                }
  844    973   
                Some(22) => {
  845    974   
                    builder.function_response_types = Some({
  846         -
                        let container = if let Some(cap) = deser.container_size() {
  847         -
                            Vec::with_capacity(cap)
  848         -
                        } else {
  849         -
                            Vec::new()
  850         -
                        };
  851         -
                        deser.read_list(member, container, |mut list, deser| {
  852         -
                            list.push(crate::types::FunctionResponseType::from(deser.read_string(member)?.as_str()));
  853         -
                            Ok(list)
  854         -
                        })?
         975  +
                        let mut container = Vec::new();
         976  +
                        deser.read_list(member, &mut |deser| {
         977  +
                            container.push(crate::types::FunctionResponseType::from(deser.read_string(member)?.as_str()));
         978  +
                            Ok(())
         979  +
                        })?;
         980  +
                        container
  855    981   
                    });
  856    982   
                }
  857    983   
                Some(23) => {
  858    984   
                    builder.amazon_managed_kafka_event_source_config = Some(crate::types::AmazonManagedKafkaEventSourceConfig::deserialize(deser)?);
  859    985   
                }
  860    986   
                Some(24) => {
  861    987   
                    builder.self_managed_kafka_event_source_config = Some(crate::types::SelfManagedKafkaEventSourceConfig::deserialize(deser)?);
  862    988   
                }
  863    989   
                Some(25) => {
  864    990   
                    builder.scaling_config = Some(crate::types::ScalingConfig::deserialize(deser)?);