AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

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   
    > {
@@ -121,125 +247,390 @@
  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    152   
    fn deserialize_nonstreaming(
  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  +
                }
  162    179   
            };
  163         -
        crate::protocol_serde::type_erase_result(parse_result)
         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  +
                        }
         252  +
                    };
         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         -
                    ));
         323  +
        let protocol = _cfg
         324  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         325  +
            .expect("a SharedClientProtocol is required");
         326  +
        if protocol.supports_http_bindings() {
         327  +
            let mut request = protocol
         328  +
                .serialize_body(&input, GetEventSourceMapping::INPUT_SCHEMA, "", _cfg)
         329  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         330  +
            {
         331  +
                let mut uri = "/2015-03-31/event-source-mappings/{UUID}".to_string();
         332  +
                let mut query_params: Vec<(String, String)> = Vec::new();
         333  +
                if let Some(ref val) = input.uuid {
         334  +
                    uri = uri.replace("{UUID}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
         335  +
                }
         336  +
                if !query_params.is_empty() {
         337  +
                    uri.push(if uri.contains('?') { '&' } else { '?' });
         338  +
                    let pairs: Vec<String> = query_params
         339  +
                        .iter()
         340  +
                        .map(|(k, v)| {
         341  +
                            format!(
         342  +
                                "{}={}",
         343  +
                                ::aws_smithy_schema::http_protocol::percent_encode(k),
         344  +
                                ::aws_smithy_schema::http_protocol::percent_encode(v)
         345  +
                            )
         346  +
                        })
         347  +
                        .collect();
         348  +
                    uri.push_str(&pairs.join("&"));
  199    349   
                }
  200         -
                ::std::write!(output, "/2015-03-31/event-source-mappings/{UUID}", UUID = uuid).expect("formatting should succeed");
  201         -
                ::std::result::Result::Ok(())
         350  +
                request.set_uri(uri.as_str()).expect("valid URI");
  202    351   
            }
  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("");
  216    352   
  217         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         353  +
            return ::std::result::Result::Ok(request);
         354  +
        } else {
         355  +
            let mut request = protocol
         356  +
                .serialize_request(&input, GetEventSourceMapping::INPUT_SCHEMA, "", _cfg)
         357  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         358  +
         359  +
            return ::std::result::Result::Ok(request);
         360  +
        }
  218    361   
    }
  219    362   
}
  220    363   
#[derive(Debug)]
  221    364   
struct GetEventSourceMappingEndpointParamsInterceptor;
  222    365   
  223    366   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetEventSourceMappingEndpointParamsInterceptor {
  224    367   
    fn name(&self) -> &'static str {
  225    368   
        "GetEventSourceMappingEndpointParamsInterceptor"
  226    369   
    }
  227    370

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)?);

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/get_function.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 `GetFunction`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetFunction;
    6      6   
impl GetFunction {
    7      7   
    /// Creates a new `GetFunction`
    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_function::GetFunctionInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_function::GetFunctionOutput::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_function::GetFunctionInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::get_function::GetFunctionOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::get_function::GetFunctionError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -119,123 +258,385 @@
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct GetFunctionResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetFunctionResponseDeserializer {
  146    150   
    fn deserialize_nonstreaming(
  147    151   
        &self,
  148    152   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         153  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  149    154   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  150    155   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  151         -
        let headers = response.headers();
  152         -
        let body = response.body().bytes().expect("body loaded");
  153    156   
        #[allow(unused_mut)]
  154    157   
        let mut force_error = false;
  155    158   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  156         -
        let parse_result = if !success && status != 200 || force_error {
  157         -
            crate::protocol_serde::shape_get_function::de_get_function_http_error(status, headers, body)
  158         -
        } else {
  159         -
            crate::protocol_serde::shape_get_function::de_get_function_http_response(status, headers, body)
         159  +
        if !success && status != 200 || force_error {
         160  +
            let headers = response.headers();
         161  +
            let body = response.body().bytes().expect("body loaded");
         162  +
            #[allow(unused_mut)]
         163  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         164  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         165  +
            })?;
         166  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         167  +
            let generic = generic_builder.build();
         168  +
            let error_code = match generic.code() {
         169  +
                ::std::option::Option::Some(code) => code,
         170  +
                ::std::option::Option::None => {
         171  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         172  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::get_function::GetFunctionError::unhandled(generic)),
         173  +
                    ))
         174  +
                }
         175  +
            };
         176  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         177  +
            let protocol = _cfg
         178  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         179  +
                .expect("a SharedClientProtocol is required");
         180  +
            let err = match error_code {
         181  +
                "InvalidParameterValueException" => crate::operation::get_function::GetFunctionError::InvalidParameterValueException({
         182  +
                    let mut tmp = match protocol
         183  +
                        .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
         184  +
                        .and_then(|mut deser| {
         185  +
                            crate::types::error::InvalidParameterValueException::deserialize_with_response(
         186  +
                                &mut *deser,
         187  +
                                response.headers(),
         188  +
                                response.status().into(),
         189  +
                                body,
         190  +
                            )
         191  +
                        }) {
         192  +
                        ::std::result::Result::Ok(val) => val,
         193  +
                        ::std::result::Result::Err(e) => {
         194  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         195  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         196  +
                            ))
         197  +
                        }
         198  +
                    };
         199  +
                    tmp.meta = generic;
         200  +
                    if tmp.message.is_none() {
         201  +
                        tmp.message = _error_message;
         202  +
                    }
         203  +
                    tmp
         204  +
                }),
         205  +
                "ResourceNotFoundException" => crate::operation::get_function::GetFunctionError::ResourceNotFoundException({
         206  +
                    let mut tmp = match protocol
         207  +
                        .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         208  +
                        .and_then(|mut deser| {
         209  +
                            crate::types::error::ResourceNotFoundException::deserialize_with_response(
         210  +
                                &mut *deser,
         211  +
                                response.headers(),
         212  +
                                response.status().into(),
         213  +
                                body,
         214  +
                            )
         215  +
                        }) {
         216  +
                        ::std::result::Result::Ok(val) => val,
         217  +
                        ::std::result::Result::Err(e) => {
         218  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         219  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         220  +
                            ))
         221  +
                        }
         222  +
                    };
         223  +
                    tmp.meta = generic;
         224  +
                    if tmp.message.is_none() {
         225  +
                        tmp.message = _error_message;
         226  +
                    }
         227  +
                    tmp
         228  +
                }),
         229  +
                "ServiceException" => crate::operation::get_function::GetFunctionError::ServiceException({
         230  +
                    let mut tmp = match protocol
         231  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         232  +
                        .and_then(|mut deser| {
         233  +
                            crate::types::error::ServiceException::deserialize_with_response(
         234  +
                                &mut *deser,
         235  +
                                response.headers(),
         236  +
                                response.status().into(),
         237  +
                                body,
         238  +
                            )
         239  +
                        }) {
         240  +
                        ::std::result::Result::Ok(val) => val,
         241  +
                        ::std::result::Result::Err(e) => {
         242  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         243  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         244  +
                            ))
         245  +
                        }
         246  +
                    };
         247  +
                    tmp.meta = generic;
         248  +
                    if tmp.message.is_none() {
         249  +
                        tmp.message = _error_message;
         250  +
                    }
         251  +
                    tmp
         252  +
                }),
         253  +
                "TooManyRequestsException" => crate::operation::get_function::GetFunctionError::TooManyRequestsException({
         254  +
                    let mut tmp = match protocol
         255  +
                        .deserialize_response(response, crate::types::error::TooManyRequestsException::SCHEMA, _cfg)
         256  +
                        .and_then(|mut deser| {
         257  +
                            crate::types::error::TooManyRequestsException::deserialize_with_response(
         258  +
                                &mut *deser,
         259  +
                                response.headers(),
         260  +
                                response.status().into(),
         261  +
                                body,
         262  +
                            )
         263  +
                        }) {
         264  +
                        ::std::result::Result::Ok(val) => val,
         265  +
                        ::std::result::Result::Err(e) => {
         266  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         267  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         268  +
                            ))
         269  +
                        }
         270  +
                    };
         271  +
                    tmp.meta = generic;
         272  +
                    if tmp.message.is_none() {
         273  +
                        tmp.message = _error_message;
         274  +
                    }
         275  +
                    tmp
         276  +
                }),
         277  +
                _ => crate::operation::get_function::GetFunctionError::generic(generic),
  160    278   
            };
  161         -
        crate::protocol_serde::type_erase_result(parse_result)
         279  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         280  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         281  +
            ))
         282  +
        } else {
         283  +
            let protocol = _cfg
         284  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         285  +
                .expect("a SharedClientProtocol is required");
         286  +
            let mut deser = protocol.deserialize_response(response, GetFunction::OUTPUT_SCHEMA, _cfg).map_err(|e| {
         287  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         288  +
            })?;
         289  +
            let body = response.body().bytes().expect("body loaded");
         290  +
            let output = crate::operation::get_function::GetFunctionOutput::deserialize_with_response(
         291  +
                &mut *deser,
         292  +
                response.headers(),
         293  +
                response.status().into(),
         294  +
                body,
         295  +
            )
         296  +
            .map_err(|e| {
         297  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         298  +
            })?;
         299  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         300  +
        }
  162    301   
    }
  163    302   
}
  164    303   
#[derive(Debug)]
  165    304   
struct GetFunctionRequestSerializer;
  166    305   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetFunctionRequestSerializer {
  167    306   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  168    307   
    fn serialize_input(
  169    308   
        &self,
  170    309   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  171    310   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  172    311   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  173    312   
        let input = input
  174    313   
            .downcast::<crate::operation::get_function::GetFunctionInput>()
  175    314   
            .expect("correct type");
  176         -
        let _header_serialization_settings = _cfg
  177         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  178         -
            .cloned()
  179         -
            .unwrap_or_default();
  180         -
        let mut request_builder = {
  181         -
            #[allow(clippy::uninlined_format_args)]
  182         -
            fn uri_base(
  183         -
                _input: &crate::operation::get_function::GetFunctionInput,
  184         -
                output: &mut ::std::string::String,
  185         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  186         -
                use ::std::fmt::Write as _;
  187         -
                let input_1 = &_input.function_name;
  188         -
                let input_1 = input_1
  189         -
                    .as_ref()
  190         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("function_name", "cannot be empty or unset"))?;
  191         -
                let function_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
  192         -
                if function_name.is_empty() {
  193         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  194         -
                        "function_name",
  195         -
                        "cannot be empty or unset",
  196         -
                    ));
  197         -
                }
  198         -
                ::std::write!(output, "/2015-03-31/functions/{FunctionName}", FunctionName = function_name).expect("formatting should succeed");
  199         -
                ::std::result::Result::Ok(())
  200         -
            }
  201         -
            fn uri_query(
  202         -
                _input: &crate::operation::get_function::GetFunctionInput,
  203         -
                mut output: &mut ::std::string::String,
  204         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  205         -
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  206         -
                if let ::std::option::Option::Some(inner_2) = &_input.qualifier {
         315  +
        let protocol = _cfg
         316  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         317  +
            .expect("a SharedClientProtocol is required");
         318  +
        if protocol.supports_http_bindings() {
         319  +
            let mut request = protocol
         320  +
                .serialize_body(&input, GetFunction::INPUT_SCHEMA, "", _cfg)
         321  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
  207    322   
            {
  208         -
                        query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
         323  +
                let mut uri = "/2015-03-31/functions/{FunctionName}".to_string();
         324  +
                let mut query_params: Vec<(String, String)> = Vec::new();
         325  +
                if let Some(ref val) = input.function_name {
         326  +
                    uri = uri.replace("{FunctionName}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
         327  +
                }
         328  +
                if let Some(ref val) = input.qualifier {
         329  +
                    query_params.push(("Qualifier".to_string(), val.to_string()));
         330  +
                }
         331  +
                if !query_params.is_empty() {
         332  +
                    uri.push(if uri.contains('?') { '&' } else { '?' });
         333  +
                    let pairs: Vec<String> = query_params
         334  +
                        .iter()
         335  +
                        .map(|(k, v)| {
         336  +
                            format!(
         337  +
                                "{}={}",
         338  +
                                ::aws_smithy_schema::http_protocol::percent_encode(k),
         339  +
                                ::aws_smithy_schema::http_protocol::percent_encode(v)
         340  +
                            )
         341  +
                        })
         342  +
                        .collect();
         343  +
                    uri.push_str(&pairs.join("&"));
  209    344   
                }
         345  +
                request.set_uri(uri.as_str()).expect("valid URI");
  210    346   
            }
  211         -
                ::std::result::Result::Ok(())
  212         -
            }
  213         -
            #[allow(clippy::unnecessary_wraps)]
  214         -
            fn update_http_builder(
  215         -
                input: &crate::operation::get_function::GetFunctionInput,
  216         -
                builder: ::http_1x::request::Builder,
  217         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  218         -
                let mut uri = ::std::string::String::new();
  219         -
                uri_base(input, &mut uri)?;
  220         -
                uri_query(input, &mut uri)?;
  221         -
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  222         -
            }
  223         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  224         -
            builder
  225         -
        };
  226         -
        let body = ::aws_smithy_types::body::SdkBody::from("");
  227    347   
  228         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         348  +
            return ::std::result::Result::Ok(request);
         349  +
        } else {
         350  +
            let mut request = protocol
         351  +
                .serialize_request(&input, GetFunction::INPUT_SCHEMA, "", _cfg)
         352  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         353  +
         354  +
            return ::std::result::Result::Ok(request);
         355  +
        }
  229    356   
    }
  230    357   
}
  231    358   
#[derive(Debug)]
  232    359   
struct GetFunctionEndpointParamsInterceptor;
  233    360   
  234    361   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetFunctionEndpointParamsInterceptor {
  235    362   
    fn name(&self) -> &'static str {
  236    363   
        "GetFunctionEndpointParamsInterceptor"
  237    364   
    }
  238    365

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

@@ -23,23 +152,169 @@
   43     43   
    "com.amazonaws.lambda.synthetic",
   44     44   
    "GetFunctionInput",
   45     45   
);
   46     46   
static GETFUNCTIONINPUT_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#GetFunctionInput$FunctionName",
   49     49   
        "com.amazonaws.lambda.synthetic",
   50     50   
        "GetFunctionInput",
   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 GETFUNCTIONINPUT_MEMBER_QUALIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.lambda.synthetic#GetFunctionInput$Qualifier",
   60     60   
        "com.amazonaws.lambda.synthetic",
   61     61   
        "GetFunctionInput",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "qualifier",
          64  +
    "Qualifier",
   65     65   
    1,
   66     66   
)
   67     67   
.with_http_query("Qualifier");
   68     68   
static GETFUNCTIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    GETFUNCTIONINPUT_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[&GETFUNCTIONINPUT_MEMBER_FUNCTION_NAME, &GETFUNCTIONINPUT_MEMBER_QUALIFIER],
   72         -
);
          72  +
)
          73  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          74  +
    "GET",
          75  +
    "/2015-03-31/functions/{FunctionName}",
          76  +
    None,
          77  +
));
   73     78   
impl GetFunctionInput {
   74     79   
    /// The schema for this shape.
   75     80   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETFUNCTIONINPUT_SCHEMA;
   76     81   
}
   77     82   
impl ::aws_smithy_schema::serde::SerializableStruct for GetFunctionInput {
   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(&GETFUNCTIONINPUT_MEMBER_FUNCTION_NAME, val)?;
   85     90   
        }
   86     91   
        if let Some(ref val) = self.qualifier {
   87     92   
            ser.write_string(&GETFUNCTIONINPUT_MEMBER_QUALIFIER, val)?;
   88     93   
        }
   89     94   
        Ok(())
   90     95   
    }
   91     96   
}
   92     97   
impl GetFunctionInput {
   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(&GETFUNCTIONINPUT_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&GETFUNCTIONINPUT_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.qualifier = 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()));
  118    124   
        builder
  119    125   
            .build()
  120    126   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  121    127   
    }
  122    128   
}
         129  +
impl GetFunctionInput {
         130  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         131  +
    pub fn deserialize_with_response(
         132  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         133  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         134  +
        _status: u16,
         135  +
        _body: &[u8],
         136  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         137  +
        Self::deserialize(deserializer)
         138  +
    }
         139  +
}
  123    140   
impl GetFunctionInput {
  124    141   
    /// Creates a new builder-style object to manufacture [`GetFunctionInput`](crate::operation::get_function::GetFunctionInput).
  125    142   
    pub fn builder() -> crate::operation::get_function::builders::GetFunctionInputBuilder {
  126    143   
        crate::operation::get_function::builders::GetFunctionInputBuilder::default()
  127    144   
    }
  128    145   
}
  129    146   
  130    147   
/// A builder for [`GetFunctionInput`](crate::operation::get_function::GetFunctionInput).
  131    148   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  132    149   
#[non_exhaustive]

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

@@ -22,22 +206,253 @@
   42     42   
    "com.amazonaws.lambda.synthetic",
   43     43   
    "GetFunctionOutput",
   44     44   
);
   45     45   
static GETFUNCTIONOUTPUT_MEMBER_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.lambda.synthetic#GetFunctionOutput$Configuration",
   48     48   
        "com.amazonaws.lambda.synthetic",
   49     49   
        "GetFunctionOutput",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52         -
    "configuration",
          52  +
    "Configuration",
   53     53   
    0,
   54     54   
);
   55     55   
static GETFUNCTIONOUTPUT_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.lambda.synthetic#GetFunctionOutput$Code",
   58     58   
        "com.amazonaws.lambda.synthetic",
   59     59   
        "GetFunctionOutput",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::Structure,
   62         -
    "code",
          62  +
    "Code",
   63     63   
    1,
   64     64   
);
   65     65   
static GETFUNCTIONOUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static(
   67     67   
        "com.amazonaws.lambda.synthetic#GetFunctionOutput$Tags",
   68     68   
        "com.amazonaws.lambda.synthetic",
   69     69   
        "GetFunctionOutput",
   70     70   
    ),
   71     71   
    ::aws_smithy_schema::ShapeType::Map,
   72         -
    "tags",
          72  +
    "Tags",
   73     73   
    2,
   74     74   
);
   75     75   
static GETFUNCTIONOUTPUT_MEMBER_TAGS_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.lambda.synthetic#GetFunctionOutput$TagsError",
   78     78   
        "com.amazonaws.lambda.synthetic",
   79     79   
        "GetFunctionOutput",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82         -
    "tags_error",
          82  +
    "TagsError",
   83     83   
    3,
   84     84   
);
   85     85   
static GETFUNCTIONOUTPUT_MEMBER_CONCURRENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.lambda.synthetic#GetFunctionOutput$Concurrency",
   88     88   
        "com.amazonaws.lambda.synthetic",
   89     89   
        "GetFunctionOutput",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::Structure,
   92         -
    "concurrency",
          92  +
    "Concurrency",
   93     93   
    4,
   94     94   
);
          95  +
static GETFUNCTIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          96  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          97  +
    ::aws_smithy_schema::ShapeType::String,
          98  +
    "request_id",
          99  +
    5,
         100  +
)
         101  +
.with_http_header("x-amzn-requestid");
   95    102   
static GETFUNCTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   96    103   
    GETFUNCTIONOUTPUT_SCHEMA_ID,
   97    104   
    ::aws_smithy_schema::ShapeType::Structure,
   98    105   
    &[
   99    106   
        &GETFUNCTIONOUTPUT_MEMBER_CONFIGURATION,
  100    107   
        &GETFUNCTIONOUTPUT_MEMBER_CODE,
  101    108   
        &GETFUNCTIONOUTPUT_MEMBER_TAGS,
  102    109   
        &GETFUNCTIONOUTPUT_MEMBER_TAGS_ERROR,
  103    110   
        &GETFUNCTIONOUTPUT_MEMBER_CONCURRENCY,
         111  +
        &GETFUNCTIONOUTPUT_MEMBER__REQUEST_ID,
  104    112   
    ],
  105    113   
);
  106    114   
impl GetFunctionOutput {
  107    115   
    /// The schema for this shape.
  108    116   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETFUNCTIONOUTPUT_SCHEMA;
  109    117   
}
  110    118   
impl ::aws_smithy_schema::serde::SerializableStruct for GetFunctionOutput {
  111    119   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  112    120   
    fn serialize_members(
  113    121   
        &self,
  114    122   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  115    123   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  116    124   
        if let Some(ref val) = self.configuration {
  117    125   
            ser.write_struct(&GETFUNCTIONOUTPUT_MEMBER_CONFIGURATION, val)?;
  118    126   
        }
  119    127   
        if let Some(ref val) = self.code {
  120    128   
            ser.write_struct(&GETFUNCTIONOUTPUT_MEMBER_CODE, val)?;
  121    129   
        }
  122    130   
        if let Some(ref val) = self.tags {
  123    131   
            ser.write_map(
  124    132   
                &GETFUNCTIONOUTPUT_MEMBER_TAGS,
  125    133   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  126    134   
                    for (key, value) in val {
  127    135   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  128    136   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
  129    137   
                    }
  130    138   
                    Ok(())
  131    139   
                },
  132    140   
            )?;
  133    141   
        }
  134    142   
        if let Some(ref val) = self.tags_error {
  135    143   
            ser.write_struct(&GETFUNCTIONOUTPUT_MEMBER_TAGS_ERROR, val)?;
  136    144   
        }
  137    145   
        if let Some(ref val) = self.concurrency {
  138    146   
            ser.write_struct(&GETFUNCTIONOUTPUT_MEMBER_CONCURRENCY, val)?;
  139    147   
        }
  140    148   
        Ok(())
  141    149   
    }
  142    150   
}
  143    151   
impl GetFunctionOutput {
  144    152   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  145         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  146         -
        deserializer: &mut D,
         153  +
    pub fn deserialize(
         154  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  147    155   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  148    156   
        #[allow(unused_variables, unused_mut)]
  149    157   
        let mut builder = Self::builder();
  150    158   
        #[allow(
  151    159   
            unused_variables,
  152    160   
            unreachable_code,
  153    161   
            clippy::single_match,
  154    162   
            clippy::match_single_binding,
  155    163   
            clippy::diverging_sub_expression
  156    164   
        )]
  157         -
        deserializer.read_struct(&GETFUNCTIONOUTPUT_SCHEMA, (), |_, member, deser| {
         165  +
        deserializer.read_struct(&GETFUNCTIONOUTPUT_SCHEMA, &mut |member, deser| {
  158    166   
            match member.member_index() {
  159    167   
                Some(0) => {
  160    168   
                    builder.configuration = Some(crate::types::FunctionConfiguration::deserialize(deser)?);
  161    169   
                }
  162    170   
                Some(1) => {
  163    171   
                    builder.code = Some(crate::types::FunctionCodeLocation::deserialize(deser)?);
  164    172   
                }
  165    173   
                Some(2) => {
  166         -
                    builder.tags = Some({
  167         -
                        let container = if let Some(cap) = deser.container_size() {
  168         -
                            std::collections::HashMap::with_capacity(cap)
  169         -
                        } else {
  170         -
                            std::collections::HashMap::new()
  171         -
                        };
  172         -
                        deser.read_map(member, container, |mut map, key, deser| {
  173         -
                            map.insert(key, deser.read_string(member)?);
  174         -
                            Ok(map)
  175         -
                        })?
  176         -
                    });
         174  +
                    builder.tags = Some(deser.read_string_string_map(member)?);
         175  +
                }
         176  +
                Some(3) => {
         177  +
                    builder.tags_error = Some(crate::types::TagsError::deserialize(deser)?);
         178  +
                }
         179  +
                Some(4) => {
         180  +
                    builder.concurrency = Some(crate::types::Concurrency::deserialize(deser)?);
         181  +
                }
         182  +
                Some(5) => {
         183  +
                    builder._request_id = Some(deser.read_string(member)?);
         184  +
                }
         185  +
                _ => {}
         186  +
            }
         187  +
            Ok(())
         188  +
        })?;
         189  +
        Ok(builder.build())
         190  +
    }
         191  +
}
         192  +
impl GetFunctionOutput {
         193  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         194  +
    /// Header-bound members are read directly from headers, avoiding runtime
         195  +
    /// member iteration overhead. Body members are read via the deserializer.
         196  +
    pub fn deserialize_with_response(
         197  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         198  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         199  +
        _status: u16,
         200  +
        _body: &[u8],
         201  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         202  +
        #[allow(unused_variables, unused_mut)]
         203  +
        let mut builder = Self::builder();
         204  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         205  +
            builder._request_id = Some(val.to_string());
         206  +
        }
         207  +
        #[allow(
         208  +
            unused_variables,
         209  +
            unreachable_code,
         210  +
            clippy::single_match,
         211  +
            clippy::match_single_binding,
         212  +
            clippy::diverging_sub_expression
         213  +
        )]
         214  +
        deserializer.read_struct(&GETFUNCTIONOUTPUT_SCHEMA, &mut |member, deser| {
         215  +
            match member.member_index() {
         216  +
                Some(0) => {
         217  +
                    builder.configuration = Some(crate::types::FunctionConfiguration::deserialize(deser)?);
         218  +
                }
         219  +
                Some(1) => {
         220  +
                    builder.code = Some(crate::types::FunctionCodeLocation::deserialize(deser)?);
         221  +
                }
         222  +
                Some(2) => {
         223  +
                    builder.tags = Some(deser.read_string_string_map(member)?);
  177    224   
                }
  178    225   
                Some(3) => {
  179    226   
                    builder.tags_error = Some(crate::types::TagsError::deserialize(deser)?);
  180    227   
                }
  181    228   
                Some(4) => {
  182    229   
                    builder.concurrency = Some(crate::types::Concurrency::deserialize(deser)?);
  183    230   
                }
  184    231   
                _ => {}
  185    232   
            }
  186    233   
            Ok(())

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

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