AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

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

@@ -1,1 +70,84 @@
    2      2   
#[allow(missing_docs)] // documentation missing in model
    3      3   
#[non_exhaustive]
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct GetAccountSettingsInput {}
    6      6   
static GETACCOUNTSETTINGSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
    7      7   
    "com.amazonaws.lambda.synthetic#GetAccountSettingsInput",
    8      8   
    "com.amazonaws.lambda.synthetic",
    9      9   
    "GetAccountSettingsInput",
   10     10   
);
   11     11   
static GETACCOUNTSETTINGSINPUT_SCHEMA: ::aws_smithy_schema::Schema =
   12         -
    ::aws_smithy_schema::Schema::new_struct(GETACCOUNTSETTINGSINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
          12  +
    ::aws_smithy_schema::Schema::new_struct(GETACCOUNTSETTINGSINPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[])
          13  +
        .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/2016-08-19/account-settings", None));
   13     14   
impl GetAccountSettingsInput {
   14     15   
    /// The schema for this shape.
   15     16   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETACCOUNTSETTINGSINPUT_SCHEMA;
   16     17   
}
   17     18   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAccountSettingsInput {
   18     19   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   19     20   
    fn serialize_members(
   20     21   
        &self,
   21     22   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   22     23   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   23     24   
        Ok(())
   24     25   
    }
   25     26   
}
   26     27   
impl GetAccountSettingsInput {
   27     28   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   28         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   29         -
        deserializer: &mut D,
          29  +
    pub fn deserialize(
          30  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   30     31   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   31     32   
        #[allow(unused_variables, unused_mut)]
   32     33   
        let mut builder = Self::builder();
   33     34   
        #[allow(
   34     35   
            unused_variables,
   35     36   
            unreachable_code,
   36     37   
            clippy::single_match,
   37     38   
            clippy::match_single_binding,
   38     39   
            clippy::diverging_sub_expression
   39     40   
        )]
   40         -
        deserializer.read_struct(&GETACCOUNTSETTINGSINPUT_SCHEMA, (), |_, member, deser| {
          41  +
        deserializer.read_struct(&GETACCOUNTSETTINGSINPUT_SCHEMA, &mut |member, deser| {
   41     42   
            match member.member_index() {
   42     43   
                _ => {}
   43     44   
            }
   44     45   
            Ok(())
   45     46   
        })?;
   46     47   
        builder
   47     48   
            .build()
   48     49   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   49     50   
    }
   50     51   
}
          52  +
impl GetAccountSettingsInput {
          53  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          54  +
    pub fn deserialize_with_response(
          55  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          56  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          57  +
        _status: u16,
          58  +
        _body: &[u8],
          59  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          60  +
        Self::builder()
          61  +
            .build()
          62  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
          63  +
    }
          64  +
}
   51     65   
impl GetAccountSettingsInput {
   52     66   
    /// Creates a new builder-style object to manufacture [`GetAccountSettingsInput`](crate::operation::get_account_settings::GetAccountSettingsInput).
   53     67   
    pub fn builder() -> crate::operation::get_account_settings::builders::GetAccountSettingsInputBuilder {
   54     68   
        crate::operation::get_account_settings::builders::GetAccountSettingsInputBuilder::default()
   55     69   
    }
   56     70   
}
   57     71   
   58     72   
/// A builder for [`GetAccountSettingsInput`](crate::operation::get_account_settings::GetAccountSettingsInput).
   59     73   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   60     74   
#[non_exhaustive]

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

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

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

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetAlias`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetAlias;
    6      6   
impl GetAlias {
    7      7   
    /// Creates a new `GetAlias`
    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::get_alias::GetAliasInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_alias::GetAliasOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::get_alias::GetAliasInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_alias::GetAliasOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_alias::GetAliasError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -111,115 +255,345 @@
  131    135   
                crate::operation::get_alias::GetAliasError,
  132    136   
            >::new());
  133    137   
  134    138   
        ::std::borrow::Cow::Owned(rcb)
  135    139   
    }
  136    140   
}
  137    141   
  138    142   
#[derive(Debug)]
  139    143   
struct GetAliasResponseDeserializer;
  140    144   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetAliasResponseDeserializer {
  141         -
    fn deserialize_nonstreaming(
         145  +
    fn deserialize_nonstreaming_with_config(
  142    146   
        &self,
  143    147   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         148  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  144    149   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  145    150   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  146         -
        let headers = response.headers();
  147         -
        let body = response.body().bytes().expect("body loaded");
  148    151   
        #[allow(unused_mut)]
  149    152   
        let mut force_error = false;
  150    153   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  151         -
        let parse_result = if !success && status != 200 || force_error {
  152         -
            crate::protocol_serde::shape_get_alias::de_get_alias_http_error(status, headers, body)
  153         -
        } else {
  154         -
            crate::protocol_serde::shape_get_alias::de_get_alias_http_response(status, headers, body)
         154  +
        if !success && status != 200 || force_error {
         155  +
            let headers = response.headers();
         156  +
            let body = response.body().bytes().expect("body loaded");
         157  +
            #[allow(unused_mut)]
         158  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         159  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         160  +
            })?;
         161  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         162  +
            let generic = generic_builder.build();
         163  +
            let error_code = match generic.code() {
         164  +
                ::std::option::Option::Some(code) => code,
         165  +
                ::std::option::Option::None => {
         166  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         167  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::get_alias::GetAliasError::unhandled(generic)),
         168  +
                    ))
         169  +
                }
         170  +
            };
         171  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         172  +
            let protocol = _cfg
         173  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         174  +
                .expect("a SharedClientProtocol is required");
         175  +
            let err = match error_code {
         176  +
                "InvalidParameterValueException" => crate::operation::get_alias::GetAliasError::InvalidParameterValueException({
         177  +
                    let mut tmp = match protocol
         178  +
                        .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
         179  +
                        .and_then(|mut deser| {
         180  +
                            crate::types::error::InvalidParameterValueException::deserialize_with_response(
         181  +
                                &mut *deser,
         182  +
                                response.headers(),
         183  +
                                response.status().into(),
         184  +
                                body,
         185  +
                            )
         186  +
                        }) {
         187  +
                        ::std::result::Result::Ok(val) => val,
         188  +
                        ::std::result::Result::Err(e) => {
         189  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         190  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         191  +
                            ))
         192  +
                        }
         193  +
                    };
         194  +
                    tmp.meta = generic;
         195  +
                    if tmp.message.is_none() {
         196  +
                        tmp.message = _error_message;
         197  +
                    }
         198  +
                    tmp
         199  +
                }),
         200  +
                "ResourceNotFoundException" => crate::operation::get_alias::GetAliasError::ResourceNotFoundException({
         201  +
                    let mut tmp = match protocol
         202  +
                        .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         203  +
                        .and_then(|mut deser| {
         204  +
                            crate::types::error::ResourceNotFoundException::deserialize_with_response(
         205  +
                                &mut *deser,
         206  +
                                response.headers(),
         207  +
                                response.status().into(),
         208  +
                                body,
         209  +
                            )
         210  +
                        }) {
         211  +
                        ::std::result::Result::Ok(val) => val,
         212  +
                        ::std::result::Result::Err(e) => {
         213  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         214  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         215  +
                            ))
         216  +
                        }
         217  +
                    };
         218  +
                    tmp.meta = generic;
         219  +
                    if tmp.message.is_none() {
         220  +
                        tmp.message = _error_message;
         221  +
                    }
         222  +
                    tmp
         223  +
                }),
         224  +
                "ServiceException" => crate::operation::get_alias::GetAliasError::ServiceException({
         225  +
                    let mut tmp = match protocol
         226  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         227  +
                        .and_then(|mut deser| {
         228  +
                            crate::types::error::ServiceException::deserialize_with_response(
         229  +
                                &mut *deser,
         230  +
                                response.headers(),
         231  +
                                response.status().into(),
         232  +
                                body,
         233  +
                            )
         234  +
                        }) {
         235  +
                        ::std::result::Result::Ok(val) => val,
         236  +
                        ::std::result::Result::Err(e) => {
         237  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         238  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         239  +
                            ))
         240  +
                        }
  155    241   
                    };
  156         -
        crate::protocol_serde::type_erase_result(parse_result)
         242  +
                    tmp.meta = generic;
         243  +
                    if tmp.message.is_none() {
         244  +
                        tmp.message = _error_message;
         245  +
                    }
         246  +
                    tmp
         247  +
                }),
         248  +
                "TooManyRequestsException" => crate::operation::get_alias::GetAliasError::TooManyRequestsException({
         249  +
                    let mut tmp = match protocol
         250  +
                        .deserialize_response(response, crate::types::error::TooManyRequestsException::SCHEMA, _cfg)
         251  +
                        .and_then(|mut deser| {
         252  +
                            crate::types::error::TooManyRequestsException::deserialize_with_response(
         253  +
                                &mut *deser,
         254  +
                                response.headers(),
         255  +
                                response.status().into(),
         256  +
                                body,
         257  +
                            )
         258  +
                        }) {
         259  +
                        ::std::result::Result::Ok(val) => val,
         260  +
                        ::std::result::Result::Err(e) => {
         261  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         262  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         263  +
                            ))
         264  +
                        }
         265  +
                    };
         266  +
                    tmp.meta = generic;
         267  +
                    if tmp.message.is_none() {
         268  +
                        tmp.message = _error_message;
         269  +
                    }
         270  +
                    tmp
         271  +
                }),
         272  +
                _ => crate::operation::get_alias::GetAliasError::generic(generic),
         273  +
            };
         274  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         275  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         276  +
            ))
         277  +
        } else {
         278  +
            let protocol = _cfg
         279  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         280  +
                .expect("a SharedClientProtocol is required");
         281  +
            let mut deser = protocol.deserialize_response(response, GetAlias::OUTPUT_SCHEMA, _cfg).map_err(|e| {
         282  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         283  +
            })?;
         284  +
            let body = response.body().bytes().expect("body loaded");
         285  +
            let output = crate::operation::get_alias::GetAliasOutput::deserialize_with_response(
         286  +
                &mut *deser,
         287  +
                response.headers(),
         288  +
                response.status().into(),
         289  +
                body,
         290  +
            )
         291  +
            .map_err(|e| {
         292  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         293  +
            })?;
         294  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         295  +
        }
  157    296   
    }
  158    297   
}
  159    298   
#[derive(Debug)]
  160    299   
struct GetAliasRequestSerializer;
  161    300   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetAliasRequestSerializer {
  162    301   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  163    302   
    fn serialize_input(
  164    303   
        &self,
  165    304   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  166    305   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  167    306   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  168    307   
        let input = input.downcast::<crate::operation::get_alias::GetAliasInput>().expect("correct type");
  169         -
        let _header_serialization_settings = _cfg
  170         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  171         -
            .cloned()
  172         -
            .unwrap_or_default();
  173         -
        let mut request_builder = {
  174         -
            #[allow(clippy::uninlined_format_args)]
  175         -
            fn uri_base(
  176         -
                _input: &crate::operation::get_alias::GetAliasInput,
  177         -
                output: &mut ::std::string::String,
  178         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  179         -
                use ::std::fmt::Write as _;
  180         -
                let input_1 = &_input.function_name;
  181         -
                let input_1 = input_1
  182         -
                    .as_ref()
  183         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("function_name", "cannot be empty or unset"))?;
  184         -
                let function_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
  185         -
                if function_name.is_empty() {
  186         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  187         -
                        "function_name",
  188         -
                        "cannot be empty or unset",
  189         -
                    ));
  190         -
                }
  191         -
                let input_2 = &_input.name;
  192         -
                let input_2 = input_2
  193         -
                    .as_ref()
  194         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
  195         -
                let name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
  196         -
                if name.is_empty() {
  197         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  198         -
                        "name",
  199         -
                        "cannot be empty or unset",
  200         -
                    ));
  201         -
                }
  202         -
                ::std::write!(
  203         -
                    output,
  204         -
                    "/2015-03-31/functions/{FunctionName}/aliases/{Name}",
  205         -
                    FunctionName = function_name,
  206         -
                    Name = name
  207         -
                )
  208         -
                .expect("formatting should succeed");
  209         -
                ::std::result::Result::Ok(())
  210         -
            }
  211         -
            #[allow(clippy::unnecessary_wraps)]
  212         -
            fn update_http_builder(
  213         -
                input: &crate::operation::get_alias::GetAliasInput,
  214         -
                builder: ::http_1x::request::Builder,
  215         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  216         -
                let mut uri = ::std::string::String::new();
  217         -
                uri_base(input, &mut uri)?;
  218         -
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  219         -
            }
  220         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  221         -
            builder
  222         -
        };
  223         -
        let body = ::aws_smithy_types::body::SdkBody::from("");
         308  +
        let protocol = _cfg
         309  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         310  +
            .expect("a SharedClientProtocol is required");
         311  +
        let mut request = protocol
         312  +
            .serialize_request(&input, GetAlias::INPUT_SCHEMA, "", _cfg)
         313  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
  224    314   
  225         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         315  +
        return ::std::result::Result::Ok(request);
  226    316   
    }
  227    317   
}
  228    318   
#[derive(Debug)]
  229    319   
struct GetAliasEndpointParamsInterceptor;
  230    320   
  231    321   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetAliasEndpointParamsInterceptor {
  232    322   
    fn name(&self) -> &'static str {
  233    323   
        "GetAliasEndpointParamsInterceptor"
  234    324   
    }
  235    325

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

@@ -23,23 +152,170 @@
   43     43   
    "com.amazonaws.lambda.synthetic",
   44     44   
    "GetAliasInput",
   45     45   
);
   46     46   
static GETALIASINPUT_MEMBER_FUNCTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static(
   48     48   
        "com.amazonaws.lambda.synthetic#GetAliasInput$FunctionName",
   49     49   
        "com.amazonaws.lambda.synthetic",
   50     50   
        "GetAliasInput",
   51     51   
    ),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "function_name",
          53  +
    "FunctionName",
   54     54   
    0,
   55     55   
)
   56     56   
.with_http_label();
   57     57   
static GETALIASINPUT_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.lambda.synthetic#GetAliasInput$Name",
   60     60   
        "com.amazonaws.lambda.synthetic",
   61     61   
        "GetAliasInput",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "name",
          64  +
    "Name",
   65     65   
    1,
   66     66   
)
   67     67   
.with_http_label();
   68     68   
static GETALIASINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    GETALIASINPUT_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[&GETALIASINPUT_MEMBER_FUNCTION_NAME, &GETALIASINPUT_MEMBER_NAME],
   72         -
);
          72  +
)
          73  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          74  +
    "GET",
          75  +
    "/2015-03-31/functions/{FunctionName}/aliases/{Name}",
          76  +
    None,
          77  +
));
   73     78   
impl GetAliasInput {
   74     79   
    /// The schema for this shape.
   75     80   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETALIASINPUT_SCHEMA;
   76     81   
}
   77     82   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAliasInput {
   78     83   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   79     84   
    fn serialize_members(
   80     85   
        &self,
   81     86   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   82     87   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   83     88   
        if let Some(ref val) = self.function_name {
   84     89   
            ser.write_string(&GETALIASINPUT_MEMBER_FUNCTION_NAME, val)?;
   85     90   
        }
   86     91   
        if let Some(ref val) = self.name {
   87     92   
            ser.write_string(&GETALIASINPUT_MEMBER_NAME, val)?;
   88     93   
        }
   89     94   
        Ok(())
   90     95   
    }
   91     96   
}
   92     97   
impl GetAliasInput {
   93     98   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   94         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   95         -
        deserializer: &mut D,
          99  +
    pub fn deserialize(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   96    101   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   97    102   
        #[allow(unused_variables, unused_mut)]
   98    103   
        let mut builder = Self::builder();
   99    104   
        #[allow(
  100    105   
            unused_variables,
  101    106   
            unreachable_code,
  102    107   
            clippy::single_match,
  103    108   
            clippy::match_single_binding,
  104    109   
            clippy::diverging_sub_expression
  105    110   
        )]
  106         -
        deserializer.read_struct(&GETALIASINPUT_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&GETALIASINPUT_SCHEMA, &mut |member, deser| {
  107    112   
            match member.member_index() {
  108    113   
                Some(0) => {
  109    114   
                    builder.function_name = Some(deser.read_string(member)?);
  110    115   
                }
  111    116   
                Some(1) => {
  112    117   
                    builder.name = Some(deser.read_string(member)?);
  113    118   
                }
  114    119   
                _ => {}
  115    120   
            }
  116    121   
            Ok(())
  117    122   
        })?;
         123  +
        builder.function_name = builder.function_name.or(Some(String::new()));
         124  +
        builder.name = builder.name.or(Some(String::new()));
  118    125   
        builder
  119    126   
            .build()
  120    127   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  121    128   
    }
  122    129   
}
         130  +
impl GetAliasInput {
         131  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         132  +
    pub fn deserialize_with_response(
         133  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         134  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         135  +
        _status: u16,
         136  +
        _body: &[u8],
         137  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         138  +
        Self::deserialize(deserializer)
         139  +
    }
         140  +
}
  123    141   
impl GetAliasInput {
  124    142   
    /// Creates a new builder-style object to manufacture [`GetAliasInput`](crate::operation::get_alias::GetAliasInput).
  125    143   
    pub fn builder() -> crate::operation::get_alias::builders::GetAliasInputBuilder {
  126    144   
        crate::operation::get_alias::builders::GetAliasInputBuilder::default()
  127    145   
    }
  128    146   
}
  129    147   
  130    148   
/// A builder for [`GetAliasInput`](crate::operation::get_alias::GetAliasInput).
  131    149   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  132    150   
#[non_exhaustive]

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

@@ -29,29 +199,259 @@
   49     49   
    "com.amazonaws.lambda.synthetic",
   50     50   
    "GetAliasOutput",
   51     51   
);
   52     52   
static GETALIASOUTPUT_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#GetAliasOutput$AliasArn",
   55     55   
        "com.amazonaws.lambda.synthetic",
   56     56   
        "GetAliasOutput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "alias_arn",
          59  +
    "AliasArn",
   60     60   
    0,
   61     61   
);
   62     62   
static GETALIASOUTPUT_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#GetAliasOutput$Name",
   65     65   
        "com.amazonaws.lambda.synthetic",
   66     66   
        "GetAliasOutput",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "name",
          69  +
    "Name",
   70     70   
    1,
   71     71   
);
   72     72   
static GETALIASOUTPUT_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#GetAliasOutput$FunctionVersion",
   75     75   
        "com.amazonaws.lambda.synthetic",
   76     76   
        "GetAliasOutput",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "function_version",
          79  +
    "FunctionVersion",
   80     80   
    2,
   81     81   
);
   82     82   
static GETALIASOUTPUT_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#GetAliasOutput$Description",
   85     85   
        "com.amazonaws.lambda.synthetic",
   86     86   
        "GetAliasOutput",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "description",
          89  +
    "Description",
   90     90   
    3,
   91     91   
);
   92     92   
static GETALIASOUTPUT_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#GetAliasOutput$RoutingConfig",
   95     95   
        "com.amazonaws.lambda.synthetic",
   96     96   
        "GetAliasOutput",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::Structure,
   99         -
    "routing_config",
          99  +
    "RoutingConfig",
  100    100   
    4,
  101    101   
);
  102    102   
static GETALIASOUTPUT_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#GetAliasOutput$RevisionId",
  105    105   
        "com.amazonaws.lambda.synthetic",
  106    106   
        "GetAliasOutput",
  107    107   
    ),
  108    108   
    ::aws_smithy_schema::ShapeType::String,
  109         -
    "revision_id",
         109  +
    "RevisionId",
  110    110   
    5,
  111    111   
);
         112  +
static GETALIASOUTPUT_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 GETALIASOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  113    120   
    GETALIASOUTPUT_SCHEMA_ID,
  114    121   
    ::aws_smithy_schema::ShapeType::Structure,
  115    122   
    &[
  116    123   
        &GETALIASOUTPUT_MEMBER_ALIAS_ARN,
  117    124   
        &GETALIASOUTPUT_MEMBER_NAME,
  118    125   
        &GETALIASOUTPUT_MEMBER_FUNCTION_VERSION,
  119    126   
        &GETALIASOUTPUT_MEMBER_DESCRIPTION,
  120    127   
        &GETALIASOUTPUT_MEMBER_ROUTING_CONFIG,
  121    128   
        &GETALIASOUTPUT_MEMBER_REVISION_ID,
         129  +
        &GETALIASOUTPUT_MEMBER__REQUEST_ID,
  122    130   
    ],
  123    131   
);
  124    132   
impl GetAliasOutput {
  125    133   
    /// The schema for this shape.
  126    134   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETALIASOUTPUT_SCHEMA;
  127    135   
}
  128    136   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAliasOutput {
  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(&GETALIASOUTPUT_MEMBER_ALIAS_ARN, val)?;
  136    144   
        }
  137    145   
        if let Some(ref val) = self.name {
  138    146   
            ser.write_string(&GETALIASOUTPUT_MEMBER_NAME, val)?;
  139    147   
        }
  140    148   
        if let Some(ref val) = self.function_version {
  141    149   
            ser.write_string(&GETALIASOUTPUT_MEMBER_FUNCTION_VERSION, val)?;
  142    150   
        }
  143    151   
        if let Some(ref val) = self.description {
  144    152   
            ser.write_string(&GETALIASOUTPUT_MEMBER_DESCRIPTION, val)?;
  145    153   
        }
  146    154   
        if let Some(ref val) = self.routing_config {
  147    155   
            ser.write_struct(&GETALIASOUTPUT_MEMBER_ROUTING_CONFIG, val)?;
  148    156   
        }
  149    157   
        if let Some(ref val) = self.revision_id {
  150    158   
            ser.write_string(&GETALIASOUTPUT_MEMBER_REVISION_ID, val)?;
  151    159   
        }
  152    160   
        Ok(())
  153    161   
    }
  154    162   
}
  155    163   
impl GetAliasOutput {
  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(&GETALIASOUTPUT_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 GetAliasOutput {
         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(&GETALIASOUTPUT_SCHEMA, (), |_, member, deser| {
         229  +
        deserializer.read_struct(&GETALIASOUTPUT_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/get_code_signing_config.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetCodeSigningConfig`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetCodeSigningConfig;
    6      6   
impl GetCodeSigningConfig {
    7      7   
    /// Creates a new `GetCodeSigningConfig`
    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::get_code_signing_config::GetCodeSigningConfigInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_code_signing_config::GetCodeSigningConfigOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::get_code_signing_config::GetCodeSigningConfigInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_code_signing_config::GetCodeSigningConfigOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_code_signing_config::GetCodeSigningConfigError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +252,336 @@
  138    142   
                crate::operation::get_code_signing_config::GetCodeSigningConfigError,
  139    143   
            >::new());
  140    144   
  141    145   
        ::std::borrow::Cow::Owned(rcb)
  142    146   
    }
  143    147   
}
  144    148   
  145    149   
#[derive(Debug)]
  146    150   
struct GetCodeSigningConfigResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetCodeSigningConfigResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         152  +
    fn deserialize_nonstreaming_with_config(
  149    153   
        &self,
  150    154   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         155  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    156   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    157   
        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    158   
        #[allow(unused_mut)]
  156    159   
        let mut force_error = false;
  157    160   
        ::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_get_code_signing_config::de_get_code_signing_config_http_error(status, headers, body)
  160         -
        } else {
  161         -
            crate::protocol_serde::shape_get_code_signing_config::de_get_code_signing_config_http_response(status, headers, body)
         161  +
        if !success && status != 200 || force_error {
         162  +
            let headers = response.headers();
         163  +
            let body = response.body().bytes().expect("body loaded");
         164  +
            #[allow(unused_mut)]
         165  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         166  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         167  +
            })?;
         168  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         169  +
            let generic = generic_builder.build();
         170  +
            let error_code = match generic.code() {
         171  +
                ::std::option::Option::Some(code) => code,
         172  +
                ::std::option::Option::None => {
         173  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         174  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         175  +
                            crate::operation::get_code_signing_config::GetCodeSigningConfigError::unhandled(generic),
         176  +
                        ),
         177  +
                    ))
         178  +
                }
         179  +
            };
         180  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         181  +
            let protocol = _cfg
         182  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         183  +
                .expect("a SharedClientProtocol is required");
         184  +
            let err = match error_code {
         185  +
                "InvalidParameterValueException" => {
         186  +
                    crate::operation::get_code_signing_config::GetCodeSigningConfigError::InvalidParameterValueException({
         187  +
                        let mut tmp = match protocol
         188  +
                            .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
         189  +
                            .and_then(|mut deser| {
         190  +
                                crate::types::error::InvalidParameterValueException::deserialize_with_response(
         191  +
                                    &mut *deser,
         192  +
                                    response.headers(),
         193  +
                                    response.status().into(),
         194  +
                                    body,
         195  +
                                )
         196  +
                            }) {
         197  +
                            ::std::result::Result::Ok(val) => val,
         198  +
                            ::std::result::Result::Err(e) => {
         199  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         200  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         201  +
                                ))
         202  +
                            }
         203  +
                        };
         204  +
                        tmp.meta = generic;
         205  +
                        if tmp.message.is_none() {
         206  +
                            tmp.message = _error_message;
         207  +
                        }
         208  +
                        tmp
         209  +
                    })
         210  +
                }
         211  +
                "ResourceNotFoundException" => crate::operation::get_code_signing_config::GetCodeSigningConfigError::ResourceNotFoundException({
         212  +
                    let mut tmp = match protocol
         213  +
                        .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         214  +
                        .and_then(|mut deser| {
         215  +
                            crate::types::error::ResourceNotFoundException::deserialize_with_response(
         216  +
                                &mut *deser,
         217  +
                                response.headers(),
         218  +
                                response.status().into(),
         219  +
                                body,
         220  +
                            )
         221  +
                        }) {
         222  +
                        ::std::result::Result::Ok(val) => val,
         223  +
                        ::std::result::Result::Err(e) => {
         224  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         225  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         226  +
                            ))
         227  +
                        }
  162    228   
                    };
  163         -
        crate::protocol_serde::type_erase_result(parse_result)
         229  +
                    tmp.meta = generic;
         230  +
                    if tmp.message.is_none() {
         231  +
                        tmp.message = _error_message;
         232  +
                    }
         233  +
                    tmp
         234  +
                }),
         235  +
                "ServiceException" => crate::operation::get_code_signing_config::GetCodeSigningConfigError::ServiceException({
         236  +
                    let mut tmp = match protocol
         237  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         238  +
                        .and_then(|mut deser| {
         239  +
                            crate::types::error::ServiceException::deserialize_with_response(
         240  +
                                &mut *deser,
         241  +
                                response.headers(),
         242  +
                                response.status().into(),
         243  +
                                body,
         244  +
                            )
         245  +
                        }) {
         246  +
                        ::std::result::Result::Ok(val) => val,
         247  +
                        ::std::result::Result::Err(e) => {
         248  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         249  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         250  +
                            ))
         251  +
                        }
         252  +
                    };
         253  +
                    tmp.meta = generic;
         254  +
                    if tmp.message.is_none() {
         255  +
                        tmp.message = _error_message;
         256  +
                    }
         257  +
                    tmp
         258  +
                }),
         259  +
                _ => crate::operation::get_code_signing_config::GetCodeSigningConfigError::generic(generic),
         260  +
            };
         261  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         262  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         263  +
            ))
         264  +
        } else {
         265  +
            let protocol = _cfg
         266  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         267  +
                .expect("a SharedClientProtocol is required");
         268  +
            let mut deser = protocol
         269  +
                .deserialize_response(response, GetCodeSigningConfig::OUTPUT_SCHEMA, _cfg)
         270  +
                .map_err(|e| {
         271  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         272  +
                })?;
         273  +
            let body = response.body().bytes().expect("body loaded");
         274  +
            let output = crate::operation::get_code_signing_config::GetCodeSigningConfigOutput::deserialize_with_response(
         275  +
                &mut *deser,
         276  +
                response.headers(),
         277  +
                response.status().into(),
         278  +
                body,
         279  +
            )
         280  +
            .map_err(|e| {
         281  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         282  +
            })?;
         283  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         284  +
        }
  164    285   
    }
  165    286   
}
  166    287   
#[derive(Debug)]
  167    288   
struct GetCodeSigningConfigRequestSerializer;
  168    289   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetCodeSigningConfigRequestSerializer {
  169    290   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  170    291   
    fn serialize_input(
  171    292   
        &self,
  172    293   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  173    294   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  174    295   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  175    296   
        let input = input
  176    297   
            .downcast::<crate::operation::get_code_signing_config::GetCodeSigningConfigInput>()
  177    298   
            .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::get_code_signing_config::GetCodeSigningConfigInput,
  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::get_code_signing_config::GetCodeSigningConfigInput,
  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("GET").uri(uri))
  216         -
            }
  217         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  218         -
            builder
  219         -
        };
  220         -
        let body = ::aws_smithy_types::body::SdkBody::from("");
         299  +
        let protocol = _cfg
         300  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         301  +
            .expect("a SharedClientProtocol is required");
         302  +
        let mut request = protocol
         303  +
            .serialize_request(&input, GetCodeSigningConfig::INPUT_SCHEMA, "", _cfg)
         304  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
  221    305   
  222         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         306  +
        return ::std::result::Result::Ok(request);
  223    307   
    }
  224    308   
}
  225    309   
#[derive(Debug)]
  226    310   
struct GetCodeSigningConfigEndpointParamsInterceptor;
  227    311   
  228    312   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetCodeSigningConfigEndpointParamsInterceptor {
  229    313   
    fn name(&self) -> &'static str {
  230    314   
        "GetCodeSigningConfigEndpointParamsInterceptor"
  231    315   
    }
  232    316

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

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

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

@@ -1,1 +96,143 @@
   18     18   
    "com.amazonaws.lambda.synthetic",
   19     19   
    "GetCodeSigningConfigOutput",
   20     20   
);
   21     21   
static GETCODESIGNINGCONFIGOUTPUT_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#GetCodeSigningConfigOutput$CodeSigningConfig",
   24     24   
        "com.amazonaws.lambda.synthetic",
   25     25   
        "GetCodeSigningConfigOutput",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "code_signing_config",
          28  +
    "CodeSigningConfig",
   29     29   
    0,
   30     30   
);
          31  +
static GETCODESIGNINGCONFIGOUTPUT_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 GETCODESIGNINGCONFIGOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     39   
    GETCODESIGNINGCONFIGOUTPUT_SCHEMA_ID,
   33     40   
    ::aws_smithy_schema::ShapeType::Structure,
   34         -
    &[&GETCODESIGNINGCONFIGOUTPUT_MEMBER_CODE_SIGNING_CONFIG],
          41  +
    &[
          42  +
        &GETCODESIGNINGCONFIGOUTPUT_MEMBER_CODE_SIGNING_CONFIG,
          43  +
        &GETCODESIGNINGCONFIGOUTPUT_MEMBER__REQUEST_ID,
          44  +
    ],
   35     45   
);
   36     46   
impl GetCodeSigningConfigOutput {
   37     47   
    /// The schema for this shape.
   38     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETCODESIGNINGCONFIGOUTPUT_SCHEMA;
   39     49   
}
   40     50   
impl ::aws_smithy_schema::serde::SerializableStruct for GetCodeSigningConfigOutput {
   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(&GETCODESIGNINGCONFIGOUTPUT_MEMBER_CODE_SIGNING_CONFIG, val)?;
   48     58   
        }
   49     59   
        Ok(())
   50     60   
    }
   51     61   
}
   52     62   
impl GetCodeSigningConfigOutput {
   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(&GETCODESIGNINGCONFIGOUTPUT_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&GETCODESIGNINGCONFIGOUTPUT_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 GetCodeSigningConfigOutput {
          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(&GETCODESIGNINGCONFIGOUTPUT_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/get_event_source_mapping.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetEventSourceMapping`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetEventSourceMapping;
    6      6   
impl GetEventSourceMapping {
    7      7   
    /// Creates a new `GetEventSourceMapping`
    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::get_event_source_mapping::GetEventSourceMappingInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_event_source_mapping::GetEventSourceMappingOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::get_event_source_mapping::GetEventSourceMappingInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_event_source_mapping::GetEventSourceMappingOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_event_source_mapping::GetEventSourceMappingError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -118,122 +247,360 @@
  138    142   
                crate::operation::get_event_source_mapping::GetEventSourceMappingError,
  139    143   
            >::new());
  140    144   
  141    145   
        ::std::borrow::Cow::Owned(rcb)
  142    146   
    }
  143    147   
}
  144    148   
  145    149   
#[derive(Debug)]
  146    150   
struct GetEventSourceMappingResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetEventSourceMappingResponseDeserializer {
  148         -
    fn deserialize_nonstreaming(
         152  +
    fn deserialize_nonstreaming_with_config(
  149    153   
        &self,
  150    154   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         155  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    156   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    157   
        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    158   
        #[allow(unused_mut)]
  156    159   
        let mut force_error = false;
  157    160   
        ::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_get_event_source_mapping::de_get_event_source_mapping_http_error(status, headers, body)
  160         -
        } else {
  161         -
            crate::protocol_serde::shape_get_event_source_mapping::de_get_event_source_mapping_http_response(status, headers, body)
         161  +
        if !success && status != 200 || force_error {
         162  +
            let headers = response.headers();
         163  +
            let body = response.body().bytes().expect("body loaded");
         164  +
            #[allow(unused_mut)]
         165  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         166  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         167  +
            })?;
         168  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         169  +
            let generic = generic_builder.build();
         170  +
            let error_code = match generic.code() {
         171  +
                ::std::option::Option::Some(code) => code,
         172  +
                ::std::option::Option::None => {
         173  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         174  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         175  +
                            crate::operation::get_event_source_mapping::GetEventSourceMappingError::unhandled(generic),
         176  +
                        ),
         177  +
                    ))
         178  +
                }
         179  +
            };
         180  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         181  +
            let protocol = _cfg
         182  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         183  +
                .expect("a SharedClientProtocol is required");
         184  +
            let err = match error_code {
         185  +
                "InvalidParameterValueException" => {
         186  +
                    crate::operation::get_event_source_mapping::GetEventSourceMappingError::InvalidParameterValueException({
         187  +
                        let mut tmp = match protocol
         188  +
                            .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
         189  +
                            .and_then(|mut deser| {
         190  +
                                crate::types::error::InvalidParameterValueException::deserialize_with_response(
         191  +
                                    &mut *deser,
         192  +
                                    response.headers(),
         193  +
                                    response.status().into(),
         194  +
                                    body,
         195  +
                                )
         196  +
                            }) {
         197  +
                            ::std::result::Result::Ok(val) => val,
         198  +
                            ::std::result::Result::Err(e) => {
         199  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         200  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         201  +
                                ))
         202  +
                            }
         203  +
                        };
         204  +
                        tmp.meta = generic;
         205  +
                        if tmp.message.is_none() {
         206  +
                            tmp.message = _error_message;
         207  +
                        }
         208  +
                        tmp
         209  +
                    })
         210  +
                }
         211  +
                "ResourceNotFoundException" => crate::operation::get_event_source_mapping::GetEventSourceMappingError::ResourceNotFoundException({
         212  +
                    let mut tmp = match protocol
         213  +
                        .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         214  +
                        .and_then(|mut deser| {
         215  +
                            crate::types::error::ResourceNotFoundException::deserialize_with_response(
         216  +
                                &mut *deser,
         217  +
                                response.headers(),
         218  +
                                response.status().into(),
         219  +
                                body,
         220  +
                            )
         221  +
                        }) {
         222  +
                        ::std::result::Result::Ok(val) => val,
         223  +
                        ::std::result::Result::Err(e) => {
         224  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         225  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         226  +
                            ))
         227  +
                        }
         228  +
                    };
         229  +
                    tmp.meta = generic;
         230  +
                    if tmp.message.is_none() {
         231  +
                        tmp.message = _error_message;
         232  +
                    }
         233  +
                    tmp
         234  +
                }),
         235  +
                "ServiceException" => crate::operation::get_event_source_mapping::GetEventSourceMappingError::ServiceException({
         236  +
                    let mut tmp = match protocol
         237  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         238  +
                        .and_then(|mut deser| {
         239  +
                            crate::types::error::ServiceException::deserialize_with_response(
         240  +
                                &mut *deser,
         241  +
                                response.headers(),
         242  +
                                response.status().into(),
         243  +
                                body,
         244  +
                            )
         245  +
                        }) {
         246  +
                        ::std::result::Result::Ok(val) => val,
         247  +
                        ::std::result::Result::Err(e) => {
         248  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         249  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         250  +
                            ))
         251  +
                        }
  162    252   
                    };
  163         -
        crate::protocol_serde::type_erase_result(parse_result)
         253  +
                    tmp.meta = generic;
         254  +
                    if tmp.message.is_none() {
         255  +
                        tmp.message = _error_message;
         256  +
                    }
         257  +
                    tmp
         258  +
                }),
         259  +
                "TooManyRequestsException" => crate::operation::get_event_source_mapping::GetEventSourceMappingError::TooManyRequestsException({
         260  +
                    let mut tmp = match protocol
         261  +
                        .deserialize_response(response, crate::types::error::TooManyRequestsException::SCHEMA, _cfg)
         262  +
                        .and_then(|mut deser| {
         263  +
                            crate::types::error::TooManyRequestsException::deserialize_with_response(
         264  +
                                &mut *deser,
         265  +
                                response.headers(),
         266  +
                                response.status().into(),
         267  +
                                body,
         268  +
                            )
         269  +
                        }) {
         270  +
                        ::std::result::Result::Ok(val) => val,
         271  +
                        ::std::result::Result::Err(e) => {
         272  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         273  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         274  +
                            ))
         275  +
                        }
         276  +
                    };
         277  +
                    tmp.meta = generic;
         278  +
                    if tmp.message.is_none() {
         279  +
                        tmp.message = _error_message;
         280  +
                    }
         281  +
                    tmp
         282  +
                }),
         283  +
                _ => crate::operation::get_event_source_mapping::GetEventSourceMappingError::generic(generic),
         284  +
            };
         285  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         286  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         287  +
            ))
         288  +
        } else {
         289  +
            let protocol = _cfg
         290  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         291  +
                .expect("a SharedClientProtocol is required");
         292  +
            let mut deser = protocol
         293  +
                .deserialize_response(response, GetEventSourceMapping::OUTPUT_SCHEMA, _cfg)
         294  +
                .map_err(|e| {
         295  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         296  +
                })?;
         297  +
            let body = response.body().bytes().expect("body loaded");
         298  +
            let output = crate::operation::get_event_source_mapping::GetEventSourceMappingOutput::deserialize_with_response(
         299  +
                &mut *deser,
         300  +
                response.headers(),
         301  +
                response.status().into(),
         302  +
                body,
         303  +
            )
         304  +
            .map_err(|e| {
         305  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         306  +
            })?;
         307  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         308  +
        }
  164    309   
    }
  165    310   
}
  166    311   
#[derive(Debug)]
  167    312   
struct GetEventSourceMappingRequestSerializer;
  168    313   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetEventSourceMappingRequestSerializer {
  169    314   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  170    315   
    fn serialize_input(
  171    316   
        &self,
  172    317   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  173    318   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  174    319   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  175    320   
        let input = input
  176    321   
            .downcast::<crate::operation::get_event_source_mapping::GetEventSourceMappingInput>()
  177    322   
            .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::get_event_source_mapping::GetEventSourceMappingInput,
  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::get_event_source_mapping::GetEventSourceMappingInput,
  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("GET").uri(uri))
  211         -
            }
  212         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  213         -
            builder
  214         -
        };
  215         -
        let body = ::aws_smithy_types::body::SdkBody::from("");
         323  +
        let protocol = _cfg
         324  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         325  +
            .expect("a SharedClientProtocol is required");
         326  +
        let mut request = protocol
         327  +
            .serialize_request(&input, GetEventSourceMapping::INPUT_SCHEMA, "", _cfg)
         328  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
  216    329   
  217         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         330  +
        return ::std::result::Result::Ok(request);
  218    331   
    }
  219    332   
}
  220    333   
#[derive(Debug)]
  221    334   
struct GetEventSourceMappingEndpointParamsInterceptor;
  222    335   
  223    336   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetEventSourceMappingEndpointParamsInterceptor {
  224    337   
    fn name(&self) -> &'static str {
  225    338   
        "GetEventSourceMappingEndpointParamsInterceptor"
  226    339   
    }
  227    340

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

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

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

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