AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

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

@@ -29,29 +199,259 @@
   49     49   
    "com.amazonaws.lambda.synthetic",
   50     50   
    "UpdateAliasOutput",
   51     51   
);
   52     52   
static UPDATEALIASOUTPUT_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#UpdateAliasOutput$AliasArn",
   55     55   
        "com.amazonaws.lambda.synthetic",
   56     56   
        "UpdateAliasOutput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "alias_arn",
          59  +
    "AliasArn",
   60     60   
    0,
   61     61   
);
   62     62   
static UPDATEALIASOUTPUT_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#UpdateAliasOutput$Name",
   65     65   
        "com.amazonaws.lambda.synthetic",
   66     66   
        "UpdateAliasOutput",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "name",
          69  +
    "Name",
   70     70   
    1,
   71     71   
);
   72     72   
static UPDATEALIASOUTPUT_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#UpdateAliasOutput$FunctionVersion",
   75     75   
        "com.amazonaws.lambda.synthetic",
   76     76   
        "UpdateAliasOutput",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "function_version",
          79  +
    "FunctionVersion",
   80     80   
    2,
   81     81   
);
   82     82   
static UPDATEALIASOUTPUT_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#UpdateAliasOutput$Description",
   85     85   
        "com.amazonaws.lambda.synthetic",
   86     86   
        "UpdateAliasOutput",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "description",
          89  +
    "Description",
   90     90   
    3,
   91     91   
);
   92     92   
static UPDATEALIASOUTPUT_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#UpdateAliasOutput$RoutingConfig",
   95     95   
        "com.amazonaws.lambda.synthetic",
   96     96   
        "UpdateAliasOutput",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::Structure,
   99         -
    "routing_config",
          99  +
    "RoutingConfig",
  100    100   
    4,
  101    101   
);
  102    102   
static UPDATEALIASOUTPUT_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#UpdateAliasOutput$RevisionId",
  105    105   
        "com.amazonaws.lambda.synthetic",
  106    106   
        "UpdateAliasOutput",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "revision_id",
         109  +
    "RevisionId",
  110    110   
    5,
  111    111   
);
         112  +
static UPDATEALIASOUTPUT_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 UPDATEALIASOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  113    120   
    UPDATEALIASOUTPUT_SCHEMA_ID,
  114    121   
    ::aws_smithy_schema::ShapeType::Structure,
  115    122   
    &[
  116    123   
        &UPDATEALIASOUTPUT_MEMBER_ALIAS_ARN,
  117    124   
        &UPDATEALIASOUTPUT_MEMBER_NAME,
  118    125   
        &UPDATEALIASOUTPUT_MEMBER_FUNCTION_VERSION,
  119    126   
        &UPDATEALIASOUTPUT_MEMBER_DESCRIPTION,
  120    127   
        &UPDATEALIASOUTPUT_MEMBER_ROUTING_CONFIG,
  121    128   
        &UPDATEALIASOUTPUT_MEMBER_REVISION_ID,
         129  +
        &UPDATEALIASOUTPUT_MEMBER__REQUEST_ID,
  122    130   
    ],
  123    131   
);
  124    132   
impl UpdateAliasOutput {
  125    133   
    /// The schema for this shape.
  126    134   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATEALIASOUTPUT_SCHEMA;
  127    135   
}
  128    136   
impl ::aws_smithy_schema::serde::SerializableStruct for UpdateAliasOutput {
  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(&UPDATEALIASOUTPUT_MEMBER_ALIAS_ARN, val)?;
  136    144   
        }
  137    145   
        if let Some(ref val) = self.name {
  138    146   
            ser.write_string(&UPDATEALIASOUTPUT_MEMBER_NAME, val)?;
  139    147   
        }
  140    148   
        if let Some(ref val) = self.function_version {
  141    149   
            ser.write_string(&UPDATEALIASOUTPUT_MEMBER_FUNCTION_VERSION, val)?;
  142    150   
        }
  143    151   
        if let Some(ref val) = self.description {
  144    152   
            ser.write_string(&UPDATEALIASOUTPUT_MEMBER_DESCRIPTION, val)?;
  145    153   
        }
  146    154   
        if let Some(ref val) = self.routing_config {
  147    155   
            ser.write_struct(&UPDATEALIASOUTPUT_MEMBER_ROUTING_CONFIG, val)?;
  148    156   
        }
  149    157   
        if let Some(ref val) = self.revision_id {
  150    158   
            ser.write_string(&UPDATEALIASOUTPUT_MEMBER_REVISION_ID, val)?;
  151    159   
        }
  152    160   
        Ok(())
  153    161   
    }
  154    162   
}
  155    163   
impl UpdateAliasOutput {
  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(&UPDATEALIASOUTPUT_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 UpdateAliasOutput {
         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(&UPDATEALIASOUTPUT_SCHEMA, (), |_, member, deser| {
         229  +
        deserializer.read_struct(&UPDATEALIASOUTPUT_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/update_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 `UpdateCodeSigningConfig`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct UpdateCodeSigningConfig;
    6      6   
impl UpdateCodeSigningConfig {
    7      7   
    /// Creates a new `UpdateCodeSigningConfig`
    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::update_code_signing_config::UpdateCodeSigningConfigInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          15  +
        crate::operation::update_code_signing_config::UpdateCodeSigningConfigOutput::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::update_code_signing_config::UpdateCodeSigningConfigInput,
   14     19   
    ) -> ::std::result::Result<
   15     20   
        crate::operation::update_code_signing_config::UpdateCodeSigningConfigOutput,
   16     21   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     22   
            crate::operation::update_code_signing_config::UpdateCodeSigningConfigError,
   18     23   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     24   
        >,
   20     25   
    > {
@@ -118,123 +258,339 @@
  138    143   
                crate::operation::update_code_signing_config::UpdateCodeSigningConfigError,
  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 UpdateCodeSigningConfigResponseDeserializer;
  147    152   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateCodeSigningConfigResponseDeserializer {
  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 != 200 || force_error {
  159         -
            crate::protocol_serde::shape_update_code_signing_config::de_update_code_signing_config_http_error(status, headers, body)
  160         -
        } else {
  161         -
            crate::protocol_serde::shape_update_code_signing_config::de_update_code_signing_config_http_response(status, headers, body)
         162  +
        if !success && status != 200 || 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::update_code_signing_config::UpdateCodeSigningConfigError::unhandled(generic),
         177  +
                        ),
         178  +
                    ))
         179  +
                }
         180  +
            };
         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::update_code_signing_config::UpdateCodeSigningConfigError::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  +
                "ResourceNotFoundException" => {
         213  +
                    crate::operation::update_code_signing_config::UpdateCodeSigningConfigError::ResourceNotFoundException({
         214  +
                        let mut tmp = match protocol
         215  +
                            .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         216  +
                            .and_then(|mut deser| {
         217  +
                                crate::types::error::ResourceNotFoundException::deserialize_with_response(
         218  +
                                    &mut *deser,
         219  +
                                    response.headers(),
         220  +
                                    response.status().into(),
         221  +
                                    body,
         222  +
                                )
         223  +
                            }) {
         224  +
                            ::std::result::Result::Ok(val) => val,
         225  +
                            ::std::result::Result::Err(e) => {
         226  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         227  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         228  +
                                ))
         229  +
                            }
         230  +
                        };
         231  +
                        tmp.meta = generic;
         232  +
                        if tmp.message.is_none() {
         233  +
                            tmp.message = _error_message;
         234  +
                        }
         235  +
                        tmp
         236  +
                    })
         237  +
                }
         238  +
                "ServiceException" => crate::operation::update_code_signing_config::UpdateCodeSigningConfigError::ServiceException({
         239  +
                    let mut tmp = match protocol
         240  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         241  +
                        .and_then(|mut deser| {
         242  +
                            crate::types::error::ServiceException::deserialize_with_response(
         243  +
                                &mut *deser,
         244  +
                                response.headers(),
         245  +
                                response.status().into(),
         246  +
                                body,
         247  +
                            )
         248  +
                        }) {
         249  +
                        ::std::result::Result::Ok(val) => val,
         250  +
                        ::std::result::Result::Err(e) => {
         251  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         252  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         253  +
                            ))
         254  +
                        }
  162    255   
                    };
  163         -
        crate::protocol_serde::type_erase_result(parse_result)
         256  +
                    tmp.meta = generic;
         257  +
                    if tmp.message.is_none() {
         258  +
                        tmp.message = _error_message;
         259  +
                    }
         260  +
                    tmp
         261  +
                }),
         262  +
                _ => crate::operation::update_code_signing_config::UpdateCodeSigningConfigError::generic(generic),
         263  +
            };
         264  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         265  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         266  +
            ))
         267  +
        } else {
         268  +
            let protocol = _cfg
         269  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         270  +
                .expect("a SharedClientProtocol is required");
         271  +
            let mut deser = protocol
         272  +
                .deserialize_response(response, UpdateCodeSigningConfig::OUTPUT_SCHEMA, _cfg)
         273  +
                .map_err(|e| {
         274  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         275  +
                })?;
         276  +
            let body = response.body().bytes().expect("body loaded");
         277  +
            let output = crate::operation::update_code_signing_config::UpdateCodeSigningConfigOutput::deserialize_with_response(
         278  +
                &mut *deser,
         279  +
                response.headers(),
         280  +
                response.status().into(),
         281  +
                body,
         282  +
            )
         283  +
            .map_err(|e| {
         284  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         285  +
            })?;
         286  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         287  +
        }
  164    288   
    }
  165    289   
}
  166    290   
#[derive(Debug)]
  167    291   
struct UpdateCodeSigningConfigRequestSerializer;
  168    292   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateCodeSigningConfigRequestSerializer {
  169    293   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  170    294   
    fn serialize_input(
  171    295   
        &self,
  172    296   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  173    297   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  174    298   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  175    299   
        let input = input
  176    300   
            .downcast::<crate::operation::update_code_signing_config::UpdateCodeSigningConfigInput>()
  177    301   
            .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::update_code_signing_config::UpdateCodeSigningConfigInput,
  186         -
                output: &mut ::std::string::String,
  187         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188         -
                use ::std::fmt::Write as _;
  189         -
                let input_1 = &_input.code_signing_config_arn;
  190         -
                let input_1 = input_1.as_ref().ok_or_else(|| {
  191         -
                    ::aws_smithy_types::error::operation::BuildError::missing_field("code_signing_config_arn", "cannot be empty or unset")
  192         -
                })?;
  193         -
                let code_signing_config_arn = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
  194         -
                if code_signing_config_arn.is_empty() {
  195         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  196         -
                        "code_signing_config_arn",
  197         -
                        "cannot be empty or unset",
  198         -
                    ));
  199         -
                }
  200         -
                ::std::write!(
  201         -
                    output,
  202         -
                    "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}",
  203         -
                    CodeSigningConfigArn = code_signing_config_arn
  204         -
                )
  205         -
                .expect("formatting should succeed");
  206         -
                ::std::result::Result::Ok(())
  207         -
            }
  208         -
            #[allow(clippy::unnecessary_wraps)]
  209         -
            fn update_http_builder(
  210         -
                input: &crate::operation::update_code_signing_config::UpdateCodeSigningConfigInput,
  211         -
                builder: ::http_1x::request::Builder,
  212         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  213         -
                let mut uri = ::std::string::String::new();
  214         -
                uri_base(input, &mut uri)?;
  215         -
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  216         -
            }
  217         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  218         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  219         -
            builder
  220         -
        };
  221         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  222         -
            crate::protocol_serde::shape_update_code_signing_config::ser_update_code_signing_config_input(&input)?,
  223         -
        );
  224         -
        if let Some(content_length) = body.content_length() {
  225         -
            let content_length = content_length.to_string();
  226         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  227         -
        }
  228         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         302  +
        let protocol = _cfg
         303  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         304  +
            .expect("a SharedClientProtocol is required");
         305  +
        let mut request = protocol
         306  +
            .serialize_request(&input, UpdateCodeSigningConfig::INPUT_SCHEMA, "", _cfg)
         307  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         308  +
         309  +
        return ::std::result::Result::Ok(request);
  229    310   
    }
  230    311   
}
  231    312   
#[derive(Debug)]
  232    313   
struct UpdateCodeSigningConfigEndpointParamsInterceptor;
  233    314   
  234    315   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateCodeSigningConfigEndpointParamsInterceptor {
  235    316   
    fn name(&self) -> &'static str {
  236    317   
        "UpdateCodeSigningConfigEndpointParamsInterceptor"
  237    318   
    }
  238    319

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

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

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

@@ -1,1 +96,143 @@
   18     18   
    "com.amazonaws.lambda.synthetic",
   19     19   
    "UpdateCodeSigningConfigOutput",
   20     20   
);
   21     21   
static UPDATECODESIGNINGCONFIGOUTPUT_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#UpdateCodeSigningConfigOutput$CodeSigningConfig",
   24     24   
        "com.amazonaws.lambda.synthetic",
   25     25   
        "UpdateCodeSigningConfigOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "code_signing_config",
          28  +
    "CodeSigningConfig",
   29     29   
    0,
   30     30   
);
          31  +
static UPDATECODESIGNINGCONFIGOUTPUT_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 UPDATECODESIGNINGCONFIGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     39   
    UPDATECODESIGNINGCONFIGOUTPUT_SCHEMA_ID,
   33     40   
    ::aws_smithy_schema::ShapeType::Structure,
   34         -
    &[&UPDATECODESIGNINGCONFIGOUTPUT_MEMBER_CODE_SIGNING_CONFIG],
          41  +
    &[
          42  +
        &UPDATECODESIGNINGCONFIGOUTPUT_MEMBER_CODE_SIGNING_CONFIG,
          43  +
        &UPDATECODESIGNINGCONFIGOUTPUT_MEMBER__REQUEST_ID,
          44  +
    ],
   35     45   
);
   36     46   
impl UpdateCodeSigningConfigOutput {
   37     47   
    /// The schema for this shape.
   38     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATECODESIGNINGCONFIGOUTPUT_SCHEMA;
   39     49   
}
   40     50   
impl ::aws_smithy_schema::serde::SerializableStruct for UpdateCodeSigningConfigOutput {
   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(&UPDATECODESIGNINGCONFIGOUTPUT_MEMBER_CODE_SIGNING_CONFIG, val)?;
   48     58   
        }
   49     59   
        Ok(())
   50     60   
    }
   51     61   
}
   52     62   
impl UpdateCodeSigningConfigOutput {
   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(&UPDATECODESIGNINGCONFIGOUTPUT_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&UPDATECODESIGNINGCONFIGOUTPUT_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 UpdateCodeSigningConfigOutput {
          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(&UPDATECODESIGNINGCONFIGOUTPUT_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/update_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 `UpdateEventSourceMapping`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct UpdateEventSourceMapping;
    6      6   
impl UpdateEventSourceMapping {
    7      7   
    /// Creates a new `UpdateEventSourceMapping`
    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::update_event_source_mapping::UpdateEventSourceMappingInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::update_event_source_mapping::UpdateEventSourceMappingOutput::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::update_event_source_mapping::UpdateEventSourceMappingInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::update_event_source_mapping::UpdateEventSourceMappingOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::update_event_source_mapping::UpdateEventSourceMappingError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -118,124 +253,416 @@
  138    144   
                crate::operation::update_event_source_mapping::UpdateEventSourceMappingError,
  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 UpdateEventSourceMappingResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateEventSourceMappingResponseDeserializer {
  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_update_event_source_mapping::de_update_event_source_mapping_http_error(status, headers, body)
  160         -
        } else {
  161         -
            crate::protocol_serde::shape_update_event_source_mapping::de_update_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::update_event_source_mapping::UpdateEventSourceMappingError::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::update_event_source_mapping::UpdateEventSourceMappingError::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::update_event_source_mapping::UpdateEventSourceMappingError::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  +
                            }
  162    231   
                        };
  163         -
        crate::protocol_serde::type_erase_result(parse_result)
         232  +
                        tmp.meta = generic;
         233  +
                        if tmp.message.is_none() {
         234  +
                            tmp.message = _error_message;
         235  +
                        }
         236  +
                        tmp
         237  +
                    })
         238  +
                }
         239  +
                "ResourceInUseException" => crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::ResourceInUseException({
         240  +
                    let mut tmp = match protocol
         241  +
                        .deserialize_response(response, crate::types::error::ResourceInUseException::SCHEMA, _cfg)
         242  +
                        .and_then(|mut deser| {
         243  +
                            crate::types::error::ResourceInUseException::deserialize_with_response(
         244  +
                                &mut *deser,
         245  +
                                response.headers(),
         246  +
                                response.status().into(),
         247  +
                                body,
         248  +
                            )
         249  +
                        }) {
         250  +
                        ::std::result::Result::Ok(val) => val,
         251  +
                        ::std::result::Result::Err(e) => {
         252  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         253  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         254  +
                            ))
         255  +
                        }
         256  +
                    };
         257  +
                    tmp.meta = generic;
         258  +
                    if tmp.message.is_none() {
         259  +
                        tmp.message = _error_message;
         260  +
                    }
         261  +
                    tmp
         262  +
                }),
         263  +
                "ResourceNotFoundException" => {
         264  +
                    crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::ResourceNotFoundException({
         265  +
                        let mut tmp = match protocol
         266  +
                            .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         267  +
                            .and_then(|mut deser| {
         268  +
                                crate::types::error::ResourceNotFoundException::deserialize_with_response(
         269  +
                                    &mut *deser,
         270  +
                                    response.headers(),
         271  +
                                    response.status().into(),
         272  +
                                    body,
         273  +
                                )
         274  +
                            }) {
         275  +
                            ::std::result::Result::Ok(val) => val,
         276  +
                            ::std::result::Result::Err(e) => {
         277  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         278  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         279  +
                                ))
         280  +
                            }
         281  +
                        };
         282  +
                        tmp.meta = generic;
         283  +
                        if tmp.message.is_none() {
         284  +
                            tmp.message = _error_message;
         285  +
                        }
         286  +
                        tmp
         287  +
                    })
         288  +
                }
         289  +
                "ServiceException" => crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::ServiceException({
         290  +
                    let mut tmp = match protocol
         291  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         292  +
                        .and_then(|mut deser| {
         293  +
                            crate::types::error::ServiceException::deserialize_with_response(
         294  +
                                &mut *deser,
         295  +
                                response.headers(),
         296  +
                                response.status().into(),
         297  +
                                body,
         298  +
                            )
         299  +
                        }) {
         300  +
                        ::std::result::Result::Ok(val) => val,
         301  +
                        ::std::result::Result::Err(e) => {
         302  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         303  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         304  +
                            ))
         305  +
                        }
         306  +
                    };
         307  +
                    tmp.meta = generic;
         308  +
                    if tmp.message.is_none() {
         309  +
                        tmp.message = _error_message;
         310  +
                    }
         311  +
                    tmp
         312  +
                }),
         313  +
                "TooManyRequestsException" => {
         314  +
                    crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::TooManyRequestsException({
         315  +
                        let mut tmp = match protocol
         316  +
                            .deserialize_response(response, crate::types::error::TooManyRequestsException::SCHEMA, _cfg)
         317  +
                            .and_then(|mut deser| {
         318  +
                                crate::types::error::TooManyRequestsException::deserialize_with_response(
         319  +
                                    &mut *deser,
         320  +
                                    response.headers(),
         321  +
                                    response.status().into(),
         322  +
                                    body,
         323  +
                                )
         324  +
                            }) {
         325  +
                            ::std::result::Result::Ok(val) => val,
         326  +
                            ::std::result::Result::Err(e) => {
         327  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         328  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         329  +
                                ))
         330  +
                            }
         331  +
                        };
         332  +
                        tmp.meta = generic;
         333  +
                        if tmp.message.is_none() {
         334  +
                            tmp.message = _error_message;
         335  +
                        }
         336  +
                        tmp
         337  +
                    })
         338  +
                }
         339  +
                _ => crate::operation::update_event_source_mapping::UpdateEventSourceMappingError::generic(generic),
         340  +
            };
         341  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         342  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         343  +
            ))
         344  +
        } else {
         345  +
            let protocol = _cfg
         346  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         347  +
                .expect("a SharedClientProtocol is required");
         348  +
            let mut deser = protocol
         349  +
                .deserialize_response(response, UpdateEventSourceMapping::OUTPUT_SCHEMA, _cfg)
         350  +
                .map_err(|e| {
         351  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         352  +
                })?;
         353  +
            let body = response.body().bytes().expect("body loaded");
         354  +
            let output = crate::operation::update_event_source_mapping::UpdateEventSourceMappingOutput::deserialize_with_response(
         355  +
                &mut *deser,
         356  +
                response.headers(),
         357  +
                response.status().into(),
         358  +
                body,
         359  +
            )
         360  +
            .map_err(|e| {
         361  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         362  +
            })?;
         363  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         364  +
        }
  164    365   
    }
  165    366   
}
  166    367   
#[derive(Debug)]
  167    368   
struct UpdateEventSourceMappingRequestSerializer;
  168    369   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateEventSourceMappingRequestSerializer {
  169    370   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  170    371   
    fn serialize_input(
  171    372   
        &self,
  172    373   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  173    374   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  174    375   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  175    376   
        let input = input
  176    377   
            .downcast::<crate::operation::update_event_source_mapping::UpdateEventSourceMappingInput>()
  177    378   
            .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::update_event_source_mapping::UpdateEventSourceMappingInput,
  186         -
                output: &mut ::std::string::String,
  187         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188         -
                use ::std::fmt::Write as _;
  189         -
                let input_1 = &_input.uuid;
  190         -
                let input_1 = input_1
  191         -
                    .as_ref()
  192         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("uuid", "cannot be empty or unset"))?;
  193         -
                let uuid = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
  194         -
                if uuid.is_empty() {
  195         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  196         -
                        "uuid",
  197         -
                        "cannot be empty or unset",
  198         -
                    ));
  199         -
                }
  200         -
                ::std::write!(output, "/2015-03-31/event-source-mappings/{UUID}", UUID = uuid).expect("formatting should succeed");
  201         -
                ::std::result::Result::Ok(())
  202         -
            }
  203         -
            #[allow(clippy::unnecessary_wraps)]
  204         -
            fn update_http_builder(
  205         -
                input: &crate::operation::update_event_source_mapping::UpdateEventSourceMappingInput,
  206         -
                builder: ::http_1x::request::Builder,
  207         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  208         -
                let mut uri = ::std::string::String::new();
  209         -
                uri_base(input, &mut uri)?;
  210         -
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  211         -
            }
  212         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  213         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  214         -
            builder
  215         -
        };
  216         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  217         -
            crate::protocol_serde::shape_update_event_source_mapping::ser_update_event_source_mapping_input(&input)?,
  218         -
        );
  219         -
        if let Some(content_length) = body.content_length() {
  220         -
            let content_length = content_length.to_string();
  221         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  222         -
        }
  223         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         379  +
        let protocol = _cfg
         380  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         381  +
            .expect("a SharedClientProtocol is required");
         382  +
        let mut request = protocol
         383  +
            .serialize_request(&input, UpdateEventSourceMapping::INPUT_SCHEMA, "", _cfg)
         384  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         385  +
         386  +
        return ::std::result::Result::Ok(request);
  224    387   
    }
  225    388   
}
  226    389   
#[derive(Debug)]
  227    390   
struct UpdateEventSourceMappingEndpointParamsInterceptor;
  228    391   
  229    392   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateEventSourceMappingEndpointParamsInterceptor {
  230    393   
    fn name(&self) -> &'static str {
  231    394   
        "UpdateEventSourceMappingEndpointParamsInterceptor"
  232    395   
    }
  233    396

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

@@ -183,183 +475,480 @@
  203    203   
    "com.amazonaws.lambda.synthetic",
  204    204   
    "UpdateEventSourceMappingInput",
  205    205   
);
  206    206   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_UUID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static(
  208    208   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$UUID",
  209    209   
        "com.amazonaws.lambda.synthetic",
  210    210   
        "UpdateEventSourceMappingInput",
  211    211   
    ),
  212    212   
    ::aws_smithy_schema::ShapeType::String,
  213         -
    "uuid",
         213  +
    "UUID",
  214    214   
    0,
  215    215   
)
  216    216   
.with_http_label();
  217    217   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_FUNCTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  218    218   
    ::aws_smithy_schema::ShapeId::from_static(
  219    219   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$FunctionName",
  220    220   
        "com.amazonaws.lambda.synthetic",
  221    221   
        "UpdateEventSourceMappingInput",
  222    222   
    ),
  223    223   
    ::aws_smithy_schema::ShapeType::String,
  224         -
    "function_name",
         224  +
    "FunctionName",
  225    225   
    1,
  226    226   
);
  227    227   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  228    228   
    ::aws_smithy_schema::ShapeId::from_static(
  229    229   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$Enabled",
  230    230   
        "com.amazonaws.lambda.synthetic",
  231    231   
        "UpdateEventSourceMappingInput",
  232    232   
    ),
  233    233   
    ::aws_smithy_schema::ShapeType::Boolean,
  234         -
    "enabled",
         234  +
    "Enabled",
  235    235   
    2,
  236    236   
);
  237    237   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_BATCH_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  238    238   
    ::aws_smithy_schema::ShapeId::from_static(
  239    239   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$BatchSize",
  240    240   
        "com.amazonaws.lambda.synthetic",
  241    241   
        "UpdateEventSourceMappingInput",
  242    242   
    ),
  243    243   
    ::aws_smithy_schema::ShapeType::Integer,
  244         -
    "batch_size",
         244  +
    "BatchSize",
  245    245   
    3,
  246    246   
);
  247    247   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_FILTER_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  248    248   
    ::aws_smithy_schema::ShapeId::from_static(
  249    249   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$FilterCriteria",
  250    250   
        "com.amazonaws.lambda.synthetic",
  251    251   
        "UpdateEventSourceMappingInput",
  252    252   
    ),
  253    253   
    ::aws_smithy_schema::ShapeType::Structure,
  254         -
    "filter_criteria",
         254  +
    "FilterCriteria",
  255    255   
    4,
  256    256   
);
  257    257   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_BATCHING_WINDOW_IN_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  258    258   
    ::aws_smithy_schema::ShapeId::from_static(
  259    259   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$MaximumBatchingWindowInSeconds",
  260    260   
        "com.amazonaws.lambda.synthetic",
  261    261   
        "UpdateEventSourceMappingInput",
  262    262   
    ),
  263    263   
    ::aws_smithy_schema::ShapeType::Integer,
  264         -
    "maximum_batching_window_in_seconds",
         264  +
    "MaximumBatchingWindowInSeconds",
  265    265   
    5,
  266    266   
);
  267    267   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_DESTINATION_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  268    268   
    ::aws_smithy_schema::ShapeId::from_static(
  269    269   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$DestinationConfig",
  270    270   
        "com.amazonaws.lambda.synthetic",
  271    271   
        "UpdateEventSourceMappingInput",
  272    272   
    ),
  273    273   
    ::aws_smithy_schema::ShapeType::Structure,
  274         -
    "destination_config",
         274  +
    "DestinationConfig",
  275    275   
    6,
  276    276   
);
  277    277   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_RECORD_AGE_IN_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  278    278   
    ::aws_smithy_schema::ShapeId::from_static(
  279    279   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$MaximumRecordAgeInSeconds",
  280    280   
        "com.amazonaws.lambda.synthetic",
  281    281   
        "UpdateEventSourceMappingInput",
  282    282   
    ),
  283    283   
    ::aws_smithy_schema::ShapeType::Integer,
  284         -
    "maximum_record_age_in_seconds",
         284  +
    "MaximumRecordAgeInSeconds",
  285    285   
    7,
  286    286   
);
  287    287   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_BISECT_BATCH_ON_FUNCTION_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  288    288   
    ::aws_smithy_schema::ShapeId::from_static(
  289    289   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$BisectBatchOnFunctionError",
  290    290   
        "com.amazonaws.lambda.synthetic",
  291    291   
        "UpdateEventSourceMappingInput",
  292    292   
    ),
  293    293   
    ::aws_smithy_schema::ShapeType::Boolean,
  294         -
    "bisect_batch_on_function_error",
         294  +
    "BisectBatchOnFunctionError",
  295    295   
    8,
  296    296   
);
  297    297   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_RETRY_ATTEMPTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  298    298   
    ::aws_smithy_schema::ShapeId::from_static(
  299    299   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$MaximumRetryAttempts",
  300    300   
        "com.amazonaws.lambda.synthetic",
  301    301   
        "UpdateEventSourceMappingInput",
  302    302   
    ),
  303    303   
    ::aws_smithy_schema::ShapeType::Integer,
  304         -
    "maximum_retry_attempts",
         304  +
    "MaximumRetryAttempts",
  305    305   
    9,
  306    306   
);
  307    307   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_PARALLELIZATION_FACTOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  308    308   
    ::aws_smithy_schema::ShapeId::from_static(
  309    309   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$ParallelizationFactor",
  310    310   
        "com.amazonaws.lambda.synthetic",
  311    311   
        "UpdateEventSourceMappingInput",
  312    312   
    ),
  313    313   
    ::aws_smithy_schema::ShapeType::Integer,
  314         -
    "parallelization_factor",
         314  +
    "ParallelizationFactor",
  315    315   
    10,
  316    316   
);
  317    317   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_SOURCE_ACCESS_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  318    318   
    ::aws_smithy_schema::ShapeId::from_static(
  319    319   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$SourceAccessConfigurations",
  320    320   
        "com.amazonaws.lambda.synthetic",
  321    321   
        "UpdateEventSourceMappingInput",
  322    322   
    ),
  323    323   
    ::aws_smithy_schema::ShapeType::List,
  324         -
    "source_access_configurations",
         324  +
    "SourceAccessConfigurations",
  325    325   
    11,
  326    326   
);
  327    327   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_TUMBLING_WINDOW_IN_SECONDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  328    328   
    ::aws_smithy_schema::ShapeId::from_static(
  329    329   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$TumblingWindowInSeconds",
  330    330   
        "com.amazonaws.lambda.synthetic",
  331    331   
        "UpdateEventSourceMappingInput",
  332    332   
    ),
  333    333   
    ::aws_smithy_schema::ShapeType::Integer,
  334         -
    "tumbling_window_in_seconds",
         334  +
    "TumblingWindowInSeconds",
  335    335   
    12,
  336    336   
);
  337    337   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_FUNCTION_RESPONSE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  338    338   
    ::aws_smithy_schema::ShapeId::from_static(
  339    339   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$FunctionResponseTypes",
  340    340   
        "com.amazonaws.lambda.synthetic",
  341    341   
        "UpdateEventSourceMappingInput",
  342    342   
    ),
  343    343   
    ::aws_smithy_schema::ShapeType::List,
  344         -
    "function_response_types",
         344  +
    "FunctionResponseTypes",
  345    345   
    13,
  346    346   
);
  347    347   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_SCALING_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  348    348   
    ::aws_smithy_schema::ShapeId::from_static(
  349    349   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$ScalingConfig",
  350    350   
        "com.amazonaws.lambda.synthetic",
  351    351   
        "UpdateEventSourceMappingInput",
  352    352   
    ),
  353    353   
    ::aws_smithy_schema::ShapeType::Structure,
  354         -
    "scaling_config",
         354  +
    "ScalingConfig",
  355    355   
    14,
  356    356   
);
  357    357   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_AMAZON_MANAGED_KAFKA_EVENT_SOURCE_CONFIG: ::aws_smithy_schema::Schema =
  358    358   
    ::aws_smithy_schema::Schema::new_member(
  359    359   
        ::aws_smithy_schema::ShapeId::from_static(
  360    360   
            "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$AmazonManagedKafkaEventSourceConfig",
  361    361   
            "com.amazonaws.lambda.synthetic",
  362    362   
            "UpdateEventSourceMappingInput",
  363    363   
        ),
  364    364   
        ::aws_smithy_schema::ShapeType::Structure,
  365         -
        "amazon_managed_kafka_event_source_config",
         365  +
        "AmazonManagedKafkaEventSourceConfig",
  366    366   
        15,
  367    367   
    );
  368    368   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_SELF_MANAGED_KAFKA_EVENT_SOURCE_CONFIG: ::aws_smithy_schema::Schema =
  369    369   
    ::aws_smithy_schema::Schema::new_member(
  370    370   
        ::aws_smithy_schema::ShapeId::from_static(
  371    371   
            "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$SelfManagedKafkaEventSourceConfig",
  372    372   
            "com.amazonaws.lambda.synthetic",
  373    373   
            "UpdateEventSourceMappingInput",
  374    374   
        ),
  375    375   
        ::aws_smithy_schema::ShapeType::Structure,
  376         -
        "self_managed_kafka_event_source_config",
         376  +
        "SelfManagedKafkaEventSourceConfig",
  377    377   
        16,
  378    378   
    );
  379    379   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_DOCUMENT_DB_EVENT_SOURCE_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  380    380   
    ::aws_smithy_schema::ShapeId::from_static(
  381    381   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$DocumentDBEventSourceConfig",
  382    382   
        "com.amazonaws.lambda.synthetic",
  383    383   
        "UpdateEventSourceMappingInput",
  384    384   
    ),
  385    385   
    ::aws_smithy_schema::ShapeType::Structure,
  386         -
    "document_db_event_source_config",
         386  +
    "DocumentDBEventSourceConfig",
  387    387   
    17,
  388    388   
);
  389    389   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_KMS_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  390    390   
    ::aws_smithy_schema::ShapeId::from_static(
  391    391   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$KMSKeyArn",
  392    392   
        "com.amazonaws.lambda.synthetic",
  393    393   
        "UpdateEventSourceMappingInput",
  394    394   
    ),
  395    395   
    ::aws_smithy_schema::ShapeType::String,
  396         -
    "kms_key_arn",
         396  +
    "KMSKeyArn",
  397    397   
    18,
  398    398   
);
  399    399   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_METRICS_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  400    400   
    ::aws_smithy_schema::ShapeId::from_static(
  401    401   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$MetricsConfig",
  402    402   
        "com.amazonaws.lambda.synthetic",
  403    403   
        "UpdateEventSourceMappingInput",
  404    404   
    ),
  405    405   
    ::aws_smithy_schema::ShapeType::Structure,
  406         -
    "metrics_config",
         406  +
    "MetricsConfig",
  407    407   
    19,
  408    408   
);
  409    409   
static UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_PROVISIONED_POLLER_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  410    410   
    ::aws_smithy_schema::ShapeId::from_static(
  411    411   
        "com.amazonaws.lambda.synthetic#UpdateEventSourceMappingInput$ProvisionedPollerConfig",
  412    412   
        "com.amazonaws.lambda.synthetic",
  413    413   
        "UpdateEventSourceMappingInput",
  414    414   
    ),
  415    415   
    ::aws_smithy_schema::ShapeType::Structure,
  416         -
    "provisioned_poller_config",
         416  +
    "ProvisionedPollerConfig",
  417    417   
    20,
  418    418   
);
  419    419   
static UPDATEEVENTSOURCEMAPPINGINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  420    420   
    UPDATEEVENTSOURCEMAPPINGINPUT_SCHEMA_ID,
  421    421   
    ::aws_smithy_schema::ShapeType::Structure,
  422    422   
    &[
  423    423   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_UUID,
  424    424   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_FUNCTION_NAME,
  425    425   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_ENABLED,
  426    426   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_BATCH_SIZE,
  427    427   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_FILTER_CRITERIA,
  428    428   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_BATCHING_WINDOW_IN_SECONDS,
  429    429   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_DESTINATION_CONFIG,
  430    430   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_RECORD_AGE_IN_SECONDS,
  431    431   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_BISECT_BATCH_ON_FUNCTION_ERROR,
  432    432   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_MAXIMUM_RETRY_ATTEMPTS,
  433    433   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_PARALLELIZATION_FACTOR,
  434    434   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_SOURCE_ACCESS_CONFIGURATIONS,
  435    435   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_TUMBLING_WINDOW_IN_SECONDS,
  436    436   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_FUNCTION_RESPONSE_TYPES,
  437    437   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_SCALING_CONFIG,
  438    438   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_AMAZON_MANAGED_KAFKA_EVENT_SOURCE_CONFIG,
  439    439   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_SELF_MANAGED_KAFKA_EVENT_SOURCE_CONFIG,
  440    440   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_DOCUMENT_DB_EVENT_SOURCE_CONFIG,
  441    441   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_KMS_KEY_ARN,
  442    442   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_METRICS_CONFIG,
  443    443   
        &UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_PROVISIONED_POLLER_CONFIG,
  444    444   
    ],
  445         -
);
         445  +
)
         446  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
         447  +
    "PUT",
         448  +
    "/2015-03-31/event-source-mappings/{UUID}",
         449  +
    Some(202),
         450  +
));
  446    451   
impl UpdateEventSourceMappingInput {
  447    452   
    /// The schema for this shape.
  448    453   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATEEVENTSOURCEMAPPINGINPUT_SCHEMA;
  449    454   
}
  450    455   
impl ::aws_smithy_schema::serde::SerializableStruct for UpdateEventSourceMappingInput {
  451    456   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  452    457   
    fn serialize_members(
  453    458   
        &self,
  454    459   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  455    460   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
@@ -510,515 +675,686 @@
  530    535   
            ser.write_struct(&UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_METRICS_CONFIG, val)?;
  531    536   
        }
  532    537   
        if let Some(ref val) = self.provisioned_poller_config {
  533    538   
            ser.write_struct(&UPDATEEVENTSOURCEMAPPINGINPUT_MEMBER_PROVISIONED_POLLER_CONFIG, val)?;
  534    539   
        }
  535    540   
        Ok(())
  536    541   
    }
  537    542   
}
  538    543   
impl UpdateEventSourceMappingInput {
  539    544   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  540         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  541         -
        deserializer: &mut D,
         545  +
    pub fn deserialize(
         546  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  542    547   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  543    548   
        #[allow(unused_variables, unused_mut)]
  544    549   
        let mut builder = Self::builder();
  545    550   
        #[allow(
  546    551   
            unused_variables,
  547    552   
            unreachable_code,
  548    553   
            clippy::single_match,
  549    554   
            clippy::match_single_binding,
  550    555   
            clippy::diverging_sub_expression
  551    556   
        )]
  552         -
        deserializer.read_struct(&UPDATEEVENTSOURCEMAPPINGINPUT_SCHEMA, (), |_, member, deser| {
         557  +
        deserializer.read_struct(&UPDATEEVENTSOURCEMAPPINGINPUT_SCHEMA, &mut |member, deser| {
  553    558   
            match member.member_index() {
  554    559   
                Some(0) => {
  555    560   
                    builder.uuid = Some(deser.read_string(member)?);
  556    561   
                }
  557    562   
                Some(1) => {
  558    563   
                    builder.function_name = Some(deser.read_string(member)?);
  559    564   
                }
  560    565   
                Some(2) => {
  561    566   
                    builder.enabled = Some(deser.read_boolean(member)?);
  562    567   
                }
  563    568   
                Some(3) => {
  564    569   
                    builder.batch_size = Some(deser.read_integer(member)?);
  565    570   
                }
  566    571   
                Some(4) => {
  567    572   
                    builder.filter_criteria = Some(crate::types::FilterCriteria::deserialize(deser)?);
  568    573   
                }
  569    574   
                Some(5) => {
  570    575   
                    builder.maximum_batching_window_in_seconds = Some(deser.read_integer(member)?);
  571    576   
                }
  572    577   
                Some(6) => {
  573    578   
                    builder.destination_config = Some(crate::types::DestinationConfig::deserialize(deser)?);
  574    579   
                }
  575    580   
                Some(7) => {
  576    581   
                    builder.maximum_record_age_in_seconds = Some(deser.read_integer(member)?);
  577    582   
                }
  578    583   
                Some(8) => {
  579    584   
                    builder.bisect_batch_on_function_error = Some(deser.read_boolean(member)?);
  580    585   
                }
  581    586   
                Some(9) => {
  582    587   
                    builder.maximum_retry_attempts = Some(deser.read_integer(member)?);
  583    588   
                }
  584    589   
                Some(10) => {
  585    590   
                    builder.parallelization_factor = Some(deser.read_integer(member)?);
  586    591   
                }
  587    592   
                Some(11) => {
  588    593   
                    builder.source_access_configurations = Some({
  589         -
                        let container = if let Some(cap) = deser.container_size() {
  590         -
                            Vec::with_capacity(cap)
  591         -
                        } else {
  592         -
                            Vec::new()
  593         -
                        };
  594         -
                        deser.read_list(member, container, |mut list, deser| {
  595         -
                            list.push(crate::types::SourceAccessConfiguration::deserialize(deser)?);
  596         -
                            Ok(list)
  597         -
                        })?
         594  +
                        let mut container = Vec::new();
         595  +
                        deser.read_list(member, &mut |deser| {
         596  +
                            container.push(crate::types::SourceAccessConfiguration::deserialize(deser)?);
         597  +
                            Ok(())
         598  +
                        })?;
         599  +
                        container
  598    600   
                    });
  599    601   
                }
  600    602   
                Some(12) => {
  601    603   
                    builder.tumbling_window_in_seconds = Some(deser.read_integer(member)?);
  602    604   
                }
  603    605   
                Some(13) => {
  604    606   
                    builder.function_response_types = Some({
  605         -
                        let container = if let Some(cap) = deser.container_size() {
  606         -
                            Vec::with_capacity(cap)
  607         -
                        } else {
  608         -
                            Vec::new()
  609         -
                        };
  610         -
                        deser.read_list(member, container, |mut list, deser| {
  611         -
                            list.push(crate::types::FunctionResponseType::from(deser.read_string(member)?.as_str()));
  612         -
                            Ok(list)
  613         -
                        })?
         607  +
                        let mut container = Vec::new();
         608  +
                        deser.read_list(member, &mut |deser| {
         609  +
                            container.push(crate::types::FunctionResponseType::from(deser.read_string(member)?.as_str()));
         610  +
                            Ok(())
         611  +
                        })?;
         612  +
                        container
  614    613   
                    });
  615    614   
                }
  616    615   
                Some(14) => {
  617    616   
                    builder.scaling_config = Some(crate::types::ScalingConfig::deserialize(deser)?);
  618    617   
                }
  619    618   
                Some(15) => {
  620    619   
                    builder.amazon_managed_kafka_event_source_config = Some(crate::types::AmazonManagedKafkaEventSourceConfig::deserialize(deser)?);
  621    620   
                }
  622    621   
                Some(16) => {
  623    622   
                    builder.self_managed_kafka_event_source_config = Some(crate::types::SelfManagedKafkaEventSourceConfig::deserialize(deser)?);
  624    623   
                }
  625    624   
                Some(17) => {
  626    625   
                    builder.document_db_event_source_config = Some(crate::types::DocumentDbEventSourceConfig::deserialize(deser)?);
  627    626   
                }
  628    627   
                Some(18) => {
  629    628   
                    builder.kms_key_arn = Some(deser.read_string(member)?);
  630    629   
                }
  631    630   
                Some(19) => {
  632    631   
                    builder.metrics_config = Some(crate::types::EventSourceMappingMetricsConfig::deserialize(deser)?);
  633    632   
                }
  634    633   
                Some(20) => {
  635    634   
                    builder.provisioned_poller_config = Some(crate::types::ProvisionedPollerConfig::deserialize(deser)?);
  636    635   
                }
  637    636   
                _ => {}
  638    637   
            }
  639    638   
            Ok(())
  640    639   
        })?;
         640  +
        builder.uuid = builder.uuid.or(Some(String::new()));
  641    641   
        builder
  642    642   
            .build()
  643    643   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  644    644   
    }
  645    645   
}
         646  +
impl UpdateEventSourceMappingInput {
         647  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         648  +
    pub fn deserialize_with_response(
         649  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         650  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         651  +
        _status: u16,
         652  +
        _body: &[u8],
         653  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         654  +
        Self::deserialize(deserializer)
         655  +
    }
         656  +
}
  646    657   
impl UpdateEventSourceMappingInput {
  647    658   
    /// Creates a new builder-style object to manufacture [`UpdateEventSourceMappingInput`](crate::operation::update_event_source_mapping::UpdateEventSourceMappingInput).
  648    659   
    pub fn builder() -> crate::operation::update_event_source_mapping::builders::UpdateEventSourceMappingInputBuilder {
  649    660   
        crate::operation::update_event_source_mapping::builders::UpdateEventSourceMappingInputBuilder::default()
  650    661   
    }
  651    662   
}
  652    663   
  653    664   
/// A builder for [`UpdateEventSourceMappingInput`](crate::operation::update_event_source_mapping::UpdateEventSourceMappingInput).
  654    665   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  655    666   
#[non_exhaustive]

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

@@ -207,207 +618,626 @@
  227    227   
    "com.amazonaws.lambda.synthetic",
  228    228   
    "UpdateEventSourceMappingOutput",
  229    229   
);
  230    230   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$UUID",
  233    233   
        "com.amazonaws.lambda.synthetic",
  234    234   
        "UpdateEventSourceMappingOutput",
  235    235   
    ),
  236    236   
    ::aws_smithy_schema::ShapeType::String,
  237         -
    "uuid",
         237  +
    "UUID",
  238    238   
    0,
  239    239   
);
  240    240   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$StartingPosition",
  243    243   
        "com.amazonaws.lambda.synthetic",
  244    244   
        "UpdateEventSourceMappingOutput",
  245    245   
    ),
  246    246   
    ::aws_smithy_schema::ShapeType::String,
  247         -
    "starting_position",
         247  +
    "StartingPosition",
  248    248   
    1,
  249    249   
);
  250    250   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$StartingPositionTimestamp",
  253    253   
        "com.amazonaws.lambda.synthetic",
  254    254   
        "UpdateEventSourceMappingOutput",
  255    255   
    ),
  256    256   
    ::aws_smithy_schema::ShapeType::Timestamp,
  257         -
    "starting_position_timestamp",
         257  +
    "StartingPositionTimestamp",
  258    258   
    2,
  259    259   
);
  260    260   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$BatchSize",
  263    263   
        "com.amazonaws.lambda.synthetic",
  264    264   
        "UpdateEventSourceMappingOutput",
  265    265   
    ),
  266    266   
    ::aws_smithy_schema::ShapeType::Integer,
  267         -
    "batch_size",
         267  +
    "BatchSize",
  268    268   
    3,
  269    269   
);
  270    270   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$MaximumBatchingWindowInSeconds",
  274    274   
            "com.amazonaws.lambda.synthetic",
  275    275   
            "UpdateEventSourceMappingOutput",
  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 UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$ParallelizationFactor",
  284    284   
        "com.amazonaws.lambda.synthetic",
  285    285   
        "UpdateEventSourceMappingOutput",
  286    286   
    ),
  287    287   
    ::aws_smithy_schema::ShapeType::Integer,
  288         -
    "parallelization_factor",
         288  +
    "ParallelizationFactor",
  289    289   
    5,
  290    290   
);
  291    291   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$EventSourceArn",
  294    294   
        "com.amazonaws.lambda.synthetic",
  295    295   
        "UpdateEventSourceMappingOutput",
  296    296   
    ),
  297    297   
    ::aws_smithy_schema::ShapeType::String,
  298         -
    "event_source_arn",
         298  +
    "EventSourceArn",
  299    299   
    6,
  300    300   
);
  301    301   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$FilterCriteria",
  304    304   
        "com.amazonaws.lambda.synthetic",
  305    305   
        "UpdateEventSourceMappingOutput",
  306    306   
    ),
  307    307   
    ::aws_smithy_schema::ShapeType::Structure,
  308         -
    "filter_criteria",
         308  +
    "FilterCriteria",
  309    309   
    7,
  310    310   
);
  311    311   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$FunctionArn",
  314    314   
        "com.amazonaws.lambda.synthetic",
  315    315   
        "UpdateEventSourceMappingOutput",
  316    316   
    ),
  317    317   
    ::aws_smithy_schema::ShapeType::String,
  318         -
    "function_arn",
         318  +
    "FunctionArn",
  319    319   
    8,
  320    320   
);
  321    321   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$LastModified",
  324    324   
        "com.amazonaws.lambda.synthetic",
  325    325   
        "UpdateEventSourceMappingOutput",
  326    326   
    ),
  327    327   
    ::aws_smithy_schema::ShapeType::Timestamp,
  328         -
    "last_modified",
         328  +
    "LastModified",
  329    329   
    9,
  330    330   
);
  331    331   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$LastProcessingResult",
  334    334   
        "com.amazonaws.lambda.synthetic",
  335    335   
        "UpdateEventSourceMappingOutput",
  336    336   
    ),
  337    337   
    ::aws_smithy_schema::ShapeType::String,
  338         -
    "last_processing_result",
         338  +
    "LastProcessingResult",
  339    339   
    10,
  340    340   
);
  341    341   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$State",
  344    344   
        "com.amazonaws.lambda.synthetic",
  345    345   
        "UpdateEventSourceMappingOutput",
  346    346   
    ),
  347    347   
    ::aws_smithy_schema::ShapeType::String,
  348         -
    "state",
         348  +
    "State",
  349    349   
    11,
  350    350   
);
  351    351   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$StateTransitionReason",
  354    354   
        "com.amazonaws.lambda.synthetic",
  355    355   
        "UpdateEventSourceMappingOutput",
  356    356   
    ),
  357    357   
    ::aws_smithy_schema::ShapeType::String,
  358         -
    "state_transition_reason",
         358  +
    "StateTransitionReason",
  359    359   
    12,
  360    360   
);
  361    361   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$DestinationConfig",
  364    364   
        "com.amazonaws.lambda.synthetic",
  365    365   
        "UpdateEventSourceMappingOutput",
  366    366   
    ),
  367    367   
    ::aws_smithy_schema::ShapeType::Structure,
  368         -
    "destination_config",
         368  +
    "DestinationConfig",
  369    369   
    13,
  370    370   
);
  371    371   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$Topics",
  374    374   
        "com.amazonaws.lambda.synthetic",
  375    375   
        "UpdateEventSourceMappingOutput",
  376    376   
    ),
  377    377   
    ::aws_smithy_schema::ShapeType::List,
  378         -
    "topics",
         378  +
    "Topics",
  379    379   
    14,
  380    380   
);
  381    381   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$Queues",
  384    384   
        "com.amazonaws.lambda.synthetic",
  385    385   
        "UpdateEventSourceMappingOutput",
  386    386   
    ),
  387    387   
    ::aws_smithy_schema::ShapeType::List,
  388         -
    "queues",
         388  +
    "Queues",
  389    389   
    15,
  390    390   
);
  391    391   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$SourceAccessConfigurations",
  394    394   
        "com.amazonaws.lambda.synthetic",
  395    395   
        "UpdateEventSourceMappingOutput",
  396    396   
    ),
  397    397   
    ::aws_smithy_schema::ShapeType::List,
  398         -
    "source_access_configurations",
         398  +
    "SourceAccessConfigurations",
  399    399   
    16,
  400    400   
);
  401    401   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$SelfManagedEventSource",
  404    404   
        "com.amazonaws.lambda.synthetic",
  405    405   
        "UpdateEventSourceMappingOutput",
  406    406   
    ),
  407    407   
    ::aws_smithy_schema::ShapeType::Structure,
  408         -
    "self_managed_event_source",
         408  +
    "SelfManagedEventSource",
  409    409   
    17,
  410    410   
);
  411    411   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$MaximumRecordAgeInSeconds",
  414    414   
        "com.amazonaws.lambda.synthetic",
  415    415   
        "UpdateEventSourceMappingOutput",
  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 UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$BisectBatchOnFunctionError",
  424    424   
        "com.amazonaws.lambda.synthetic",
  425    425   
        "UpdateEventSourceMappingOutput",
  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 UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$MaximumRetryAttempts",
  434    434   
        "com.amazonaws.lambda.synthetic",
  435    435   
        "UpdateEventSourceMappingOutput",
  436    436   
    ),
  437    437   
    ::aws_smithy_schema::ShapeType::Integer,
  438         -
    "maximum_retry_attempts",
         438  +
    "MaximumRetryAttempts",
  439    439   
    20,
  440    440   
);
  441    441   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$TumblingWindowInSeconds",
  444    444   
        "com.amazonaws.lambda.synthetic",
  445    445   
        "UpdateEventSourceMappingOutput",
  446    446   
    ),
  447    447   
    ::aws_smithy_schema::ShapeType::Integer,
  448         -
    "tumbling_window_in_seconds",
         448  +
    "TumblingWindowInSeconds",
  449    449   
    21,
  450    450   
);
  451    451   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$FunctionResponseTypes",
  454    454   
        "com.amazonaws.lambda.synthetic",
  455    455   
        "UpdateEventSourceMappingOutput",
  456    456   
    ),
  457    457   
    ::aws_smithy_schema::ShapeType::List,
  458         -
    "function_response_types",
         458  +
    "FunctionResponseTypes",
  459    459   
    22,
  460    460   
);
  461    461   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$AmazonManagedKafkaEventSourceConfig",
  465    465   
            "com.amazonaws.lambda.synthetic",
  466    466   
            "UpdateEventSourceMappingOutput",
  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 UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$SelfManagedKafkaEventSourceConfig",
  476    476   
            "com.amazonaws.lambda.synthetic",
  477    477   
            "UpdateEventSourceMappingOutput",
  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 UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$ScalingConfig",
  486    486   
        "com.amazonaws.lambda.synthetic",
  487    487   
        "UpdateEventSourceMappingOutput",
  488    488   
    ),
  489    489   
    ::aws_smithy_schema::ShapeType::Structure,
  490         -
    "scaling_config",
         490  +
    "ScalingConfig",
  491    491   
    25,
  492    492   
);
  493    493   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$DocumentDBEventSourceConfig",
  496    496   
        "com.amazonaws.lambda.synthetic",
  497    497   
        "UpdateEventSourceMappingOutput",
  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 UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$KMSKeyArn",
  506    506   
        "com.amazonaws.lambda.synthetic",
  507    507   
        "UpdateEventSourceMappingOutput",
  508    508   
    ),
  509    509   
    ::aws_smithy_schema::ShapeType::String,
  510         -
    "kms_key_arn",
         510  +
    "KMSKeyArn",
  511    511   
    27,
  512    512   
);
  513    513   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$FilterCriteriaError",
  516    516   
        "com.amazonaws.lambda.synthetic",
  517    517   
        "UpdateEventSourceMappingOutput",
  518    518   
    ),
  519    519   
    ::aws_smithy_schema::ShapeType::Structure,
  520         -
    "filter_criteria_error",
         520  +
    "FilterCriteriaError",
  521    521   
    28,
  522    522   
);
  523    523   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$EventSourceMappingArn",
  526    526   
        "com.amazonaws.lambda.synthetic",
  527    527   
        "UpdateEventSourceMappingOutput",
  528    528   
    ),
  529    529   
    ::aws_smithy_schema::ShapeType::String,
  530         -
    "event_source_mapping_arn",
         530  +
    "EventSourceMappingArn",
  531    531   
    29,
  532    532   
);
  533    533   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$MetricsConfig",
  536    536   
        "com.amazonaws.lambda.synthetic",
  537    537   
        "UpdateEventSourceMappingOutput",
  538    538   
    ),
  539    539   
    ::aws_smithy_schema::ShapeType::Structure,
  540         -
    "metrics_config",
         540  +
    "MetricsConfig",
  541    541   
    30,
  542    542   
);
  543    543   
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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#UpdateEventSourceMappingOutput$ProvisionedPollerConfig",
  546    546   
        "com.amazonaws.lambda.synthetic",
  547    547   
        "UpdateEventSourceMappingOutput",
  548    548   
    ),
  549    549   
    ::aws_smithy_schema::ShapeType::Structure,
  550         -
    "provisioned_poller_config",
         550  +
    "ProvisionedPollerConfig",
  551    551   
    31,
  552    552   
);
         553  +
static UPDATEEVENTSOURCEMAPPINGOUTPUT_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 UPDATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  554    561   
    UPDATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA_ID,
  555    562   
    ::aws_smithy_schema::ShapeType::Structure,
  556    563   
    &[
  557    564   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_UUID,
  558    565   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STARTING_POSITION,
  559    566   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STARTING_POSITION_TIMESTAMP,
  560    567   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_BATCH_SIZE,
  561    568   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_MAXIMUM_BATCHING_WINDOW_IN_SECONDS,
  562    569   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_PARALLELIZATION_FACTOR,
  563    570   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_EVENT_SOURCE_ARN,
  564    571   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FILTER_CRITERIA,
  565    572   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FUNCTION_ARN,
  566    573   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_LAST_MODIFIED,
  567    574   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_LAST_PROCESSING_RESULT,
  568    575   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STATE,
  569    576   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_STATE_TRANSITION_REASON,
  570    577   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_DESTINATION_CONFIG,
  571    578   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_TOPICS,
  572    579   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_QUEUES,
  573    580   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SOURCE_ACCESS_CONFIGURATIONS,
  574    581   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SELF_MANAGED_EVENT_SOURCE,
  575    582   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_MAXIMUM_RECORD_AGE_IN_SECONDS,
  576    583   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_BISECT_BATCH_ON_FUNCTION_ERROR,
  577    584   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_MAXIMUM_RETRY_ATTEMPTS,
  578    585   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_TUMBLING_WINDOW_IN_SECONDS,
  579    586   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FUNCTION_RESPONSE_TYPES,
  580    587   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_AMAZON_MANAGED_KAFKA_EVENT_SOURCE_CONFIG,
  581    588   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SELF_MANAGED_KAFKA_EVENT_SOURCE_CONFIG,
  582    589   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_SCALING_CONFIG,
  583    590   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_DOCUMENT_DB_EVENT_SOURCE_CONFIG,
  584    591   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_KMS_KEY_ARN,
  585    592   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_FILTER_CRITERIA_ERROR,
  586    593   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_EVENT_SOURCE_MAPPING_ARN,
  587    594   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_METRICS_CONFIG,
  588    595   
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_PROVISIONED_POLLER_CONFIG,
         596  +
        &UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER__REQUEST_ID,
  589    597   
    ],
  590    598   
);
  591    599   
impl UpdateEventSourceMappingOutput {
  592    600   
    /// The schema for this shape.
  593    601   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA;
  594    602   
}
  595    603   
impl ::aws_smithy_schema::serde::SerializableStruct for UpdateEventSourceMappingOutput {
  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(&UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_METRICS_CONFIG, val)?;
  725    733   
        }
  726    734   
        if let Some(ref val) = self.provisioned_poller_config {
  727    735   
            ser.write_struct(&UPDATEEVENTSOURCEMAPPINGOUTPUT_MEMBER_PROVISIONED_POLLER_CONFIG, val)?;
  728    736   
        }
  729    737   
        Ok(())
  730    738   
    }
  731    739   
}
  732    740   
impl UpdateEventSourceMappingOutput {
  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(&UPDATEEVENTSOURCEMAPPINGOUTPUT_SCHEMA, (), |_, member, deser| {
         754  +
        deserializer.read_struct(&UPDATEEVENTSOURCEMAPPINGOUTPUT_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 UpdateEventSourceMappingOutput {
         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(&UPDATEEVENTSOURCEMAPPINGOUTPUT_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)?);