AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

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

@@ -29,29 +179,196 @@
   49     49   
    "com.amazonaws.lambda.synthetic",
   50     50   
    "ListVersionsByFunctionInput",
   51     51   
);
   52     52   
static LISTVERSIONSBYFUNCTIONINPUT_MEMBER_FUNCTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.lambda.synthetic#ListVersionsByFunctionInput$FunctionName",
   55     55   
        "com.amazonaws.lambda.synthetic",
   56     56   
        "ListVersionsByFunctionInput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "function_name",
          59  +
    "FunctionName",
   60     60   
    0,
   61     61   
)
   62     62   
.with_http_label();
   63     63   
static LISTVERSIONSBYFUNCTIONINPUT_MEMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.lambda.synthetic#ListVersionsByFunctionInput$Marker",
   66     66   
        "com.amazonaws.lambda.synthetic",
   67     67   
        "ListVersionsByFunctionInput",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70         -
    "marker",
          70  +
    "Marker",
   71     71   
    1,
   72     72   
)
   73     73   
.with_http_query("Marker");
   74     74   
static LISTVERSIONSBYFUNCTIONINPUT_MEMBER_MAX_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.lambda.synthetic#ListVersionsByFunctionInput$MaxItems",
   77     77   
        "com.amazonaws.lambda.synthetic",
   78     78   
        "ListVersionsByFunctionInput",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::Integer,
   81         -
    "max_items",
          81  +
    "MaxItems",
   82     82   
    2,
   83     83   
)
   84     84   
.with_http_query("MaxItems");
   85     85   
static LISTVERSIONSBYFUNCTIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   86     86   
    LISTVERSIONSBYFUNCTIONINPUT_SCHEMA_ID,
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88     88   
    &[
   89     89   
        &LISTVERSIONSBYFUNCTIONINPUT_MEMBER_FUNCTION_NAME,
   90     90   
        &LISTVERSIONSBYFUNCTIONINPUT_MEMBER_MARKER,
   91     91   
        &LISTVERSIONSBYFUNCTIONINPUT_MEMBER_MAX_ITEMS,
   92     92   
    ],
   93         -
);
          93  +
)
          94  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
          95  +
    "GET",
          96  +
    "/2015-03-31/functions/{FunctionName}/versions",
          97  +
    None,
          98  +
));
   94     99   
impl ListVersionsByFunctionInput {
   95    100   
    /// The schema for this shape.
   96    101   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTVERSIONSBYFUNCTIONINPUT_SCHEMA;
   97    102   
}
   98    103   
impl ::aws_smithy_schema::serde::SerializableStruct for ListVersionsByFunctionInput {
   99    104   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  100    105   
    fn serialize_members(
  101    106   
        &self,
  102    107   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  103    108   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  104    109   
        if let Some(ref val) = self.function_name {
  105    110   
            ser.write_string(&LISTVERSIONSBYFUNCTIONINPUT_MEMBER_FUNCTION_NAME, val)?;
  106    111   
        }
  107    112   
        if let Some(ref val) = self.marker {
  108    113   
            ser.write_string(&LISTVERSIONSBYFUNCTIONINPUT_MEMBER_MARKER, val)?;
  109    114   
        }
  110    115   
        if let Some(ref val) = self.max_items {
  111    116   
            ser.write_integer(&LISTVERSIONSBYFUNCTIONINPUT_MEMBER_MAX_ITEMS, *val)?;
  112    117   
        }
  113    118   
        Ok(())
  114    119   
    }
  115    120   
}
  116    121   
impl ListVersionsByFunctionInput {
  117    122   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  118         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  119         -
        deserializer: &mut D,
         123  +
    pub fn deserialize(
         124  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  120    125   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  121    126   
        #[allow(unused_variables, unused_mut)]
  122    127   
        let mut builder = Self::builder();
  123    128   
        #[allow(
  124    129   
            unused_variables,
  125    130   
            unreachable_code,
  126    131   
            clippy::single_match,
  127    132   
            clippy::match_single_binding,
  128    133   
            clippy::diverging_sub_expression
  129    134   
        )]
  130         -
        deserializer.read_struct(&LISTVERSIONSBYFUNCTIONINPUT_SCHEMA, (), |_, member, deser| {
         135  +
        deserializer.read_struct(&LISTVERSIONSBYFUNCTIONINPUT_SCHEMA, &mut |member, deser| {
  131    136   
            match member.member_index() {
  132    137   
                Some(0) => {
  133    138   
                    builder.function_name = Some(deser.read_string(member)?);
  134    139   
                }
  135    140   
                Some(1) => {
  136    141   
                    builder.marker = Some(deser.read_string(member)?);
  137    142   
                }
  138    143   
                Some(2) => {
  139    144   
                    builder.max_items = Some(deser.read_integer(member)?);
  140    145   
                }
  141    146   
                _ => {}
  142    147   
            }
  143    148   
            Ok(())
  144    149   
        })?;
         150  +
        builder.function_name = builder.function_name.or(Some(String::new()));
  145    151   
        builder
  146    152   
            .build()
  147    153   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  148    154   
    }
  149    155   
}
         156  +
impl ListVersionsByFunctionInput {
         157  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         158  +
    pub fn deserialize_with_response(
         159  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         160  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         161  +
        _status: u16,
         162  +
        _body: &[u8],
         163  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         164  +
        Self::deserialize(deserializer)
         165  +
    }
         166  +
}
  150    167   
impl ListVersionsByFunctionInput {
  151    168   
    /// Creates a new builder-style object to manufacture [`ListVersionsByFunctionInput`](crate::operation::list_versions_by_function::ListVersionsByFunctionInput).
  152    169   
    pub fn builder() -> crate::operation::list_versions_by_function::builders::ListVersionsByFunctionInputBuilder {
  153    170   
        crate::operation::list_versions_by_function::builders::ListVersionsByFunctionInputBuilder::default()
  154    171   
    }
  155    172   
}
  156    173   
  157    174   
/// A builder for [`ListVersionsByFunctionInput`](crate::operation::list_versions_by_function::ListVersionsByFunctionInput).
  158    175   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  159    176   
#[non_exhaustive]

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

@@ -6,6 +143,195 @@
   26     26   
    "com.amazonaws.lambda.synthetic",
   27     27   
    "ListVersionsByFunctionOutput",
   28     28   
);
   29     29   
static LISTVERSIONSBYFUNCTIONOUTPUT_MEMBER_NEXT_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.lambda.synthetic#ListVersionsByFunctionOutput$NextMarker",
   32     32   
        "com.amazonaws.lambda.synthetic",
   33     33   
        "ListVersionsByFunctionOutput",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "next_marker",
          36  +
    "NextMarker",
   37     37   
    0,
   38     38   
);
   39     39   
static LISTVERSIONSBYFUNCTIONOUTPUT_MEMBER_VERSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.lambda.synthetic#ListVersionsByFunctionOutput$Versions",
   42     42   
        "com.amazonaws.lambda.synthetic",
   43     43   
        "ListVersionsByFunctionOutput",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::List,
   46         -
    "versions",
          46  +
    "Versions",
   47     47   
    1,
   48     48   
);
          49  +
static LISTVERSIONSBYFUNCTIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          50  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          51  +
    ::aws_smithy_schema::ShapeType::String,
          52  +
    "request_id",
          53  +
    2,
          54  +
)
          55  +
.with_http_header("x-amzn-requestid");
   49     56   
static LISTVERSIONSBYFUNCTIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     57   
    LISTVERSIONSBYFUNCTIONOUTPUT_SCHEMA_ID,
   51     58   
    ::aws_smithy_schema::ShapeType::Structure,
   52     59   
    &[
   53     60   
        &LISTVERSIONSBYFUNCTIONOUTPUT_MEMBER_NEXT_MARKER,
   54     61   
        &LISTVERSIONSBYFUNCTIONOUTPUT_MEMBER_VERSIONS,
          62  +
        &LISTVERSIONSBYFUNCTIONOUTPUT_MEMBER__REQUEST_ID,
   55     63   
    ],
   56     64   
);
   57     65   
impl ListVersionsByFunctionOutput {
   58     66   
    /// The schema for this shape.
   59     67   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTVERSIONSBYFUNCTIONOUTPUT_SCHEMA;
   60     68   
}
   61     69   
impl ::aws_smithy_schema::serde::SerializableStruct for ListVersionsByFunctionOutput {
   62     70   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   63     71   
    fn serialize_members(
   64     72   
        &self,
   65     73   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   66     74   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   67     75   
        if let Some(ref val) = self.next_marker {
   68     76   
            ser.write_string(&LISTVERSIONSBYFUNCTIONOUTPUT_MEMBER_NEXT_MARKER, val)?;
   69     77   
        }
   70     78   
        if let Some(ref val) = self.versions {
   71     79   
            ser.write_list(
   72     80   
                &LISTVERSIONSBYFUNCTIONOUTPUT_MEMBER_VERSIONS,
   73     81   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   74     82   
                    for item in val {
   75     83   
                        ser.write_struct(crate::types::FunctionConfiguration::SCHEMA, item)?;
   76     84   
                    }
   77     85   
                    Ok(())
   78     86   
                },
   79     87   
            )?;
   80     88   
        }
   81     89   
        Ok(())
   82     90   
    }
   83     91   
}
   84     92   
impl ListVersionsByFunctionOutput {
   85     93   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   86         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   87         -
        deserializer: &mut D,
          94  +
    pub fn deserialize(
          95  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   88     96   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   89     97   
        #[allow(unused_variables, unused_mut)]
   90     98   
        let mut builder = Self::builder();
   91     99   
        #[allow(
   92    100   
            unused_variables,
   93    101   
            unreachable_code,
   94    102   
            clippy::single_match,
   95    103   
            clippy::match_single_binding,
   96    104   
            clippy::diverging_sub_expression
   97    105   
        )]
   98         -
        deserializer.read_struct(&LISTVERSIONSBYFUNCTIONOUTPUT_SCHEMA, (), |_, member, deser| {
         106  +
        deserializer.read_struct(&LISTVERSIONSBYFUNCTIONOUTPUT_SCHEMA, &mut |member, deser| {
   99    107   
            match member.member_index() {
  100    108   
                Some(0) => {
  101    109   
                    builder.next_marker = Some(deser.read_string(member)?);
  102    110   
                }
  103    111   
                Some(1) => {
  104    112   
                    builder.versions = Some({
  105         -
                        let container = if let Some(cap) = deser.container_size() {
  106         -
                            Vec::with_capacity(cap)
  107         -
                        } else {
  108         -
                            Vec::new()
  109         -
                        };
  110         -
                        deser.read_list(member, container, |mut list, deser| {
  111         -
                            list.push(crate::types::FunctionConfiguration::deserialize(deser)?);
  112         -
                            Ok(list)
  113         -
                        })?
         113  +
                        let mut container = Vec::new();
         114  +
                        deser.read_list(member, &mut |deser| {
         115  +
                            container.push(crate::types::FunctionConfiguration::deserialize(deser)?);
         116  +
                            Ok(())
         117  +
                        })?;
         118  +
                        container
         119  +
                    });
         120  +
                }
         121  +
                Some(2) => {
         122  +
                    builder._request_id = Some(deser.read_string(member)?);
         123  +
                }
         124  +
                _ => {}
         125  +
            }
         126  +
            Ok(())
         127  +
        })?;
         128  +
        Ok(builder.build())
         129  +
    }
         130  +
}
         131  +
impl ListVersionsByFunctionOutput {
         132  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         133  +
    /// Header-bound members are read directly from headers, avoiding runtime
         134  +
    /// member iteration overhead. Body members are read via the deserializer.
         135  +
    pub fn deserialize_with_response(
         136  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         137  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         138  +
        _status: u16,
         139  +
        _body: &[u8],
         140  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         141  +
        #[allow(unused_variables, unused_mut)]
         142  +
        let mut builder = Self::builder();
         143  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         144  +
            builder._request_id = Some(val.to_string());
         145  +
        }
         146  +
        #[allow(
         147  +
            unused_variables,
         148  +
            unreachable_code,
         149  +
            clippy::single_match,
         150  +
            clippy::match_single_binding,
         151  +
            clippy::diverging_sub_expression
         152  +
        )]
         153  +
        deserializer.read_struct(&LISTVERSIONSBYFUNCTIONOUTPUT_SCHEMA, &mut |member, deser| {
         154  +
            match member.member_index() {
         155  +
                Some(0) => {
         156  +
                    builder.next_marker = Some(deser.read_string(member)?);
         157  +
                }
         158  +
                Some(1) => {
         159  +
                    builder.versions = Some({
         160  +
                        let mut container = Vec::new();
         161  +
                        deser.read_list(member, &mut |deser| {
         162  +
                            container.push(crate::types::FunctionConfiguration::deserialize(deser)?);
         163  +
                            Ok(())
         164  +
                        })?;
         165  +
                        container
  114    166   
                    });
  115    167   
                }
  116    168   
                _ => {}
  117    169   
            }
  118    170   
            Ok(())
  119    171   
        })?;
  120    172   
        Ok(builder.build())
  121    173   
    }
  122    174   
}
  123    175   
impl ::aws_types::request_id::RequestId for ListVersionsByFunctionOutput {

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/publish_layer_version.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 `PublishLayerVersion`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct PublishLayerVersion;
    6      6   
impl PublishLayerVersion {
    7      7   
    /// Creates a new `PublishLayerVersion`
    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::publish_layer_version::PublishLayerVersionInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::publish_layer_version::PublishLayerVersionOutput::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::publish_layer_version::PublishLayerVersionInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::publish_layer_version::PublishLayerVersionOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::publish_layer_version::PublishLayerVersionError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -121,125 +253,414 @@
  141    145   
        ::std::borrow::Cow::Owned(rcb)
  142    146   
    }
  143    147   
}
  144    148   
  145    149   
#[derive(Debug)]
  146    150   
struct PublishLayerVersionResponseDeserializer;
  147    151   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PublishLayerVersionResponseDeserializer {
  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 != 201 || force_error {
  159         -
            crate::protocol_serde::shape_publish_layer_version::de_publish_layer_version_http_error(status, headers, body)
  160         -
        } else {
  161         -
            crate::protocol_serde::shape_publish_layer_version::de_publish_layer_version_http_response(status, headers, body)
         161  +
        if !success && status != 201 || 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::publish_layer_version::PublishLayerVersionError::unhandled(generic),
         176  +
                        ),
         177  +
                    ))
         178  +
                }
         179  +
            };
         180  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         181  +
            let protocol = _cfg
         182  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         183  +
                .expect("a SharedClientProtocol is required");
         184  +
            let err = match error_code {
         185  +
                "CodeStorageExceededException" => crate::operation::publish_layer_version::PublishLayerVersionError::CodeStorageExceededException({
         186  +
                    let mut tmp = match protocol
         187  +
                        .deserialize_response(response, crate::types::error::CodeStorageExceededException::SCHEMA, _cfg)
         188  +
                        .and_then(|mut deser| {
         189  +
                            crate::types::error::CodeStorageExceededException::deserialize_with_response(
         190  +
                                &mut *deser,
         191  +
                                response.headers(),
         192  +
                                response.status().into(),
         193  +
                                body,
         194  +
                            )
         195  +
                        }) {
         196  +
                        ::std::result::Result::Ok(val) => val,
         197  +
                        ::std::result::Result::Err(e) => {
         198  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         199  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         200  +
                            ))
         201  +
                        }
         202  +
                    };
         203  +
                    tmp.meta = generic;
         204  +
                    if tmp.message.is_none() {
         205  +
                        tmp.message = _error_message;
         206  +
                    }
         207  +
                    tmp
         208  +
                }),
         209  +
                "InvalidParameterValueException" => {
         210  +
                    crate::operation::publish_layer_version::PublishLayerVersionError::InvalidParameterValueException({
         211  +
                        let mut tmp = match protocol
         212  +
                            .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
         213  +
                            .and_then(|mut deser| {
         214  +
                                crate::types::error::InvalidParameterValueException::deserialize_with_response(
         215  +
                                    &mut *deser,
         216  +
                                    response.headers(),
         217  +
                                    response.status().into(),
         218  +
                                    body,
         219  +
                                )
         220  +
                            }) {
         221  +
                            ::std::result::Result::Ok(val) => val,
         222  +
                            ::std::result::Result::Err(e) => {
         223  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         224  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         225  +
                                ))
         226  +
                            }
         227  +
                        };
         228  +
                        tmp.meta = generic;
         229  +
                        if tmp.message.is_none() {
         230  +
                            tmp.message = _error_message;
         231  +
                        }
         232  +
                        tmp
         233  +
                    })
         234  +
                }
         235  +
                "ResourceNotFoundException" => crate::operation::publish_layer_version::PublishLayerVersionError::ResourceNotFoundException({
         236  +
                    let mut tmp = match protocol
         237  +
                        .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         238  +
                        .and_then(|mut deser| {
         239  +
                            crate::types::error::ResourceNotFoundException::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  +
                "ServiceException" => crate::operation::publish_layer_version::PublishLayerVersionError::ServiceException({
         260  +
                    let mut tmp = match protocol
         261  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         262  +
                        .and_then(|mut deser| {
         263  +
                            crate::types::error::ServiceException::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  +
                "TooManyRequestsException" => crate::operation::publish_layer_version::PublishLayerVersionError::TooManyRequestsException({
         284  +
                    let mut tmp = match protocol
         285  +
                        .deserialize_response(response, crate::types::error::TooManyRequestsException::SCHEMA, _cfg)
         286  +
                        .and_then(|mut deser| {
         287  +
                            crate::types::error::TooManyRequestsException::deserialize_with_response(
         288  +
                                &mut *deser,
         289  +
                                response.headers(),
         290  +
                                response.status().into(),
         291  +
                                body,
         292  +
                            )
         293  +
                        }) {
         294  +
                        ::std::result::Result::Ok(val) => val,
         295  +
                        ::std::result::Result::Err(e) => {
         296  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         297  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         298  +
                            ))
         299  +
                        }
  162    300   
                    };
  163         -
        crate::protocol_serde::type_erase_result(parse_result)
         301  +
                    tmp.meta = generic;
         302  +
                    if tmp.message.is_none() {
         303  +
                        tmp.message = _error_message;
         304  +
                    }
         305  +
                    tmp
         306  +
                }),
         307  +
                _ => crate::operation::publish_layer_version::PublishLayerVersionError::generic(generic),
         308  +
            };
         309  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         310  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         311  +
            ))
         312  +
        } else {
         313  +
            let protocol = _cfg
         314  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         315  +
                .expect("a SharedClientProtocol is required");
         316  +
            let mut deser = protocol
         317  +
                .deserialize_response(response, PublishLayerVersion::OUTPUT_SCHEMA, _cfg)
         318  +
                .map_err(|e| {
         319  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         320  +
                })?;
         321  +
            let body = response.body().bytes().expect("body loaded");
         322  +
            let output = crate::operation::publish_layer_version::PublishLayerVersionOutput::deserialize_with_response(
         323  +
                &mut *deser,
         324  +
                response.headers(),
         325  +
                response.status().into(),
         326  +
                body,
         327  +
            )
         328  +
            .map_err(|e| {
         329  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         330  +
            })?;
         331  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         332  +
        }
  164    333   
    }
  165    334   
}
  166    335   
#[derive(Debug)]
  167    336   
struct PublishLayerVersionRequestSerializer;
  168    337   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PublishLayerVersionRequestSerializer {
  169    338   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  170    339   
    fn serialize_input(
  171    340   
        &self,
  172    341   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  173    342   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  174    343   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  175    344   
        let input = input
  176    345   
            .downcast::<crate::operation::publish_layer_version::PublishLayerVersionInput>()
  177    346   
            .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::publish_layer_version::PublishLayerVersionInput,
  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.layer_name;
  190         -
                let input_1 = input_1
  191         -
                    .as_ref()
  192         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("layer_name", "cannot be empty or unset"))?;
  193         -
                let layer_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
  194         -
                if layer_name.is_empty() {
  195         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  196         -
                        "layer_name",
  197         -
                        "cannot be empty or unset",
  198         -
                    ));
         347  +
        let protocol = _cfg
         348  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         349  +
            .expect("a SharedClientProtocol is required");
         350  +
        if protocol.supports_http_bindings() {
         351  +
            let mut request = protocol
         352  +
                .serialize_body(&input, PublishLayerVersion::INPUT_SCHEMA, "", _cfg)
         353  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         354  +
            {
         355  +
                let mut uri = "/2018-10-31/layers/{LayerName}/versions".to_string();
         356  +
                let mut query_params: Vec<(String, String)> = Vec::new();
         357  +
                if let Some(ref val) = input.layer_name {
         358  +
                    uri = uri.replace("{LayerName}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
         359  +
                }
         360  +
                if !query_params.is_empty() {
         361  +
                    uri.push(if uri.contains('?') { '&' } else { '?' });
         362  +
                    let pairs: Vec<String> = query_params
         363  +
                        .iter()
         364  +
                        .map(|(k, v)| {
         365  +
                            format!(
         366  +
                                "{}={}",
         367  +
                                ::aws_smithy_schema::http_protocol::percent_encode(k),
         368  +
                                ::aws_smithy_schema::http_protocol::percent_encode(v)
         369  +
                            )
         370  +
                        })
         371  +
                        .collect();
         372  +
                    uri.push_str(&pairs.join("&"));
  199    373   
                }
  200         -
                ::std::write!(output, "/2018-10-31/layers/{LayerName}/versions", LayerName = layer_name).expect("formatting should succeed");
  201         -
                ::std::result::Result::Ok(())
         374  +
                request.set_uri(uri.as_str()).expect("valid URI");
         375  +
            }
         376  +
         377  +
            return ::std::result::Result::Ok(request);
         378  +
        } else {
         379  +
            let mut request = protocol
         380  +
                .serialize_request(&input, PublishLayerVersion::INPUT_SCHEMA, "", _cfg)
         381  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         382  +
         383  +
            return ::std::result::Result::Ok(request);
  202    384   
        }
  203         -
            #[allow(clippy::unnecessary_wraps)]
  204         -
            fn update_http_builder(
  205         -
                input: &crate::operation::publish_layer_version::PublishLayerVersionInput,
  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("POST").uri(uri))
  211         -
            }
  212         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  213         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  214         -
            builder
  215         -
        };
  216         -
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_publish_layer_version::ser_publish_layer_version_input(
  217         -
            &input,
  218         -
        )?);
  219         -
        if let Some(content_length) = body.content_length() {
  220         -
            let content_length = content_length.to_string();
  221         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  222         -
        }
  223         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  224    385   
    }
  225    386   
}
  226    387   
#[derive(Debug)]
  227    388   
struct PublishLayerVersionEndpointParamsInterceptor;
  228    389   
  229    390   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PublishLayerVersionEndpointParamsInterceptor {
  230    391   
    fn name(&self) -> &'static str {
  231    392   
        "PublishLayerVersionEndpointParamsInterceptor"
  232    393   
    }
  233    394

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

@@ -49,49 +284,295 @@
   69     69   
    "com.amazonaws.lambda.synthetic",
   70     70   
    "PublishLayerVersionInput",
   71     71   
);
   72     72   
static PUBLISHLAYERVERSIONINPUT_MEMBER_LAYER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionInput$LayerName",
   75     75   
        "com.amazonaws.lambda.synthetic",
   76     76   
        "PublishLayerVersionInput",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::String,
   79         -
    "layer_name",
          79  +
    "LayerName",
   80     80   
    0,
   81     81   
)
   82     82   
.with_http_label();
   83     83   
static PUBLISHLAYERVERSIONINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionInput$Description",
   86     86   
        "com.amazonaws.lambda.synthetic",
   87     87   
        "PublishLayerVersionInput",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::String,
   90         -
    "description",
          90  +
    "Description",
   91     91   
    1,
   92     92   
);
   93     93   
static PUBLISHLAYERVERSIONINPUT_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionInput$Content",
   96     96   
        "com.amazonaws.lambda.synthetic",
   97     97   
        "PublishLayerVersionInput",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::Structure,
  100         -
    "content",
         100  +
    "Content",
  101    101   
    2,
  102    102   
);
  103    103   
static PUBLISHLAYERVERSIONINPUT_MEMBER_COMPATIBLE_RUNTIMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionInput$CompatibleRuntimes",
  106    106   
        "com.amazonaws.lambda.synthetic",
  107    107   
        "PublishLayerVersionInput",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::List,
  110         -
    "compatible_runtimes",
         110  +
    "CompatibleRuntimes",
  111    111   
    3,
  112    112   
);
  113    113   
static PUBLISHLAYERVERSIONINPUT_MEMBER_LICENSE_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionInput$LicenseInfo",
  116    116   
        "com.amazonaws.lambda.synthetic",
  117    117   
        "PublishLayerVersionInput",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::String,
  120         -
    "license_info",
         120  +
    "LicenseInfo",
  121    121   
    4,
  122    122   
);
  123    123   
static PUBLISHLAYERVERSIONINPUT_MEMBER_COMPATIBLE_ARCHITECTURES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionInput$CompatibleArchitectures",
  126    126   
        "com.amazonaws.lambda.synthetic",
  127    127   
        "PublishLayerVersionInput",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::List,
  130         -
    "compatible_architectures",
         130  +
    "CompatibleArchitectures",
  131    131   
    5,
  132    132   
);
  133    133   
static PUBLISHLAYERVERSIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  134    134   
    PUBLISHLAYERVERSIONINPUT_SCHEMA_ID,
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136    136   
    &[
  137    137   
        &PUBLISHLAYERVERSIONINPUT_MEMBER_LAYER_NAME,
  138    138   
        &PUBLISHLAYERVERSIONINPUT_MEMBER_DESCRIPTION,
  139    139   
        &PUBLISHLAYERVERSIONINPUT_MEMBER_CONTENT,
  140    140   
        &PUBLISHLAYERVERSIONINPUT_MEMBER_COMPATIBLE_RUNTIMES,
  141    141   
        &PUBLISHLAYERVERSIONINPUT_MEMBER_LICENSE_INFO,
  142    142   
        &PUBLISHLAYERVERSIONINPUT_MEMBER_COMPATIBLE_ARCHITECTURES,
  143    143   
    ],
  144         -
);
         144  +
)
         145  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
         146  +
    "POST",
         147  +
    "/2018-10-31/layers/{LayerName}/versions",
         148  +
    Some(201),
         149  +
));
  145    150   
impl PublishLayerVersionInput {
  146    151   
    /// The schema for this shape.
  147    152   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUBLISHLAYERVERSIONINPUT_SCHEMA;
  148    153   
}
  149    154   
impl ::aws_smithy_schema::serde::SerializableStruct for PublishLayerVersionInput {
  150    155   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  151    156   
    fn serialize_members(
  152    157   
        &self,
  153    158   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  154    159   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  155    160   
        if let Some(ref val) = self.layer_name {
  156    161   
            ser.write_string(&PUBLISHLAYERVERSIONINPUT_MEMBER_LAYER_NAME, val)?;
  157    162   
        }
  158    163   
        if let Some(ref val) = self.description {
  159    164   
            ser.write_string(&PUBLISHLAYERVERSIONINPUT_MEMBER_DESCRIPTION, val)?;
  160    165   
        }
  161    166   
        if let Some(ref val) = self.content {
  162    167   
            ser.write_struct(&PUBLISHLAYERVERSIONINPUT_MEMBER_CONTENT, val)?;
  163    168   
        }
  164    169   
        if let Some(ref val) = self.compatible_runtimes {
  165    170   
            ser.write_list(
  166    171   
                &PUBLISHLAYERVERSIONINPUT_MEMBER_COMPATIBLE_RUNTIMES,
  167    172   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  168    173   
                    for item in val {
  169    174   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
  170    175   
                    }
  171    176   
                    Ok(())
  172    177   
                },
  173    178   
            )?;
  174    179   
        }
  175    180   
        if let Some(ref val) = self.license_info {
  176    181   
            ser.write_string(&PUBLISHLAYERVERSIONINPUT_MEMBER_LICENSE_INFO, val)?;
  177    182   
        }
  178    183   
        if let Some(ref val) = self.compatible_architectures {
  179    184   
            ser.write_list(
  180    185   
                &PUBLISHLAYERVERSIONINPUT_MEMBER_COMPATIBLE_ARCHITECTURES,
  181    186   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  182    187   
                    for item in val {
  183    188   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
  184    189   
                    }
  185    190   
                    Ok(())
  186    191   
                },
  187    192   
            )?;
  188    193   
        }
  189    194   
        Ok(())
  190    195   
    }
  191    196   
}
  192    197   
impl PublishLayerVersionInput {
  193    198   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  194         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  195         -
        deserializer: &mut D,
         199  +
    pub fn deserialize(
         200  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  196    201   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  197    202   
        #[allow(unused_variables, unused_mut)]
  198    203   
        let mut builder = Self::builder();
  199    204   
        #[allow(
  200    205   
            unused_variables,
  201    206   
            unreachable_code,
  202    207   
            clippy::single_match,
  203    208   
            clippy::match_single_binding,
  204    209   
            clippy::diverging_sub_expression
  205    210   
        )]
  206         -
        deserializer.read_struct(&PUBLISHLAYERVERSIONINPUT_SCHEMA, (), |_, member, deser| {
         211  +
        deserializer.read_struct(&PUBLISHLAYERVERSIONINPUT_SCHEMA, &mut |member, deser| {
  207    212   
            match member.member_index() {
  208    213   
                Some(0) => {
  209    214   
                    builder.layer_name = Some(deser.read_string(member)?);
  210    215   
                }
  211    216   
                Some(1) => {
  212    217   
                    builder.description = Some(deser.read_string(member)?);
  213    218   
                }
  214    219   
                Some(2) => {
  215    220   
                    builder.content = Some(crate::types::LayerVersionContentInput::deserialize(deser)?);
  216    221   
                }
  217    222   
                Some(3) => {
  218    223   
                    builder.compatible_runtimes = Some({
  219         -
                        let container = if let Some(cap) = deser.container_size() {
  220         -
                            Vec::with_capacity(cap)
  221         -
                        } else {
  222         -
                            Vec::new()
  223         -
                        };
  224         -
                        deser.read_list(member, container, |mut list, deser| {
  225         -
                            list.push(crate::types::Runtime::from(deser.read_string(member)?.as_str()));
  226         -
                            Ok(list)
  227         -
                        })?
         224  +
                        let mut container = Vec::new();
         225  +
                        deser.read_list(member, &mut |deser| {
         226  +
                            container.push(crate::types::Runtime::from(deser.read_string(member)?.as_str()));
         227  +
                            Ok(())
         228  +
                        })?;
         229  +
                        container
  228    230   
                    });
  229    231   
                }
  230    232   
                Some(4) => {
  231    233   
                    builder.license_info = Some(deser.read_string(member)?);
  232    234   
                }
  233    235   
                Some(5) => {
  234    236   
                    builder.compatible_architectures = Some({
  235         -
                        let container = if let Some(cap) = deser.container_size() {
  236         -
                            Vec::with_capacity(cap)
  237         -
                        } else {
  238         -
                            Vec::new()
  239         -
                        };
  240         -
                        deser.read_list(member, container, |mut list, deser| {
  241         -
                            list.push(crate::types::Architecture::from(deser.read_string(member)?.as_str()));
  242         -
                            Ok(list)
  243         -
                        })?
         237  +
                        let mut container = Vec::new();
         238  +
                        deser.read_list(member, &mut |deser| {
         239  +
                            container.push(crate::types::Architecture::from(deser.read_string(member)?.as_str()));
         240  +
                            Ok(())
         241  +
                        })?;
         242  +
                        container
  244    243   
                    });
  245    244   
                }
  246    245   
                _ => {}
  247    246   
            }
  248    247   
            Ok(())
  249    248   
        })?;
         249  +
        builder.layer_name = builder.layer_name.or(Some(String::new()));
  250    250   
        builder
  251    251   
            .build()
  252    252   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  253    253   
    }
  254    254   
}
         255  +
impl PublishLayerVersionInput {
         256  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         257  +
    pub fn deserialize_with_response(
         258  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         259  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         260  +
        _status: u16,
         261  +
        _body: &[u8],
         262  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         263  +
        Self::deserialize(deserializer)
         264  +
    }
         265  +
}
  255    266   
impl PublishLayerVersionInput {
  256    267   
    /// Creates a new builder-style object to manufacture [`PublishLayerVersionInput`](crate::operation::publish_layer_version::PublishLayerVersionInput).
  257    268   
    pub fn builder() -> crate::operation::publish_layer_version::builders::PublishLayerVersionInputBuilder {
  258    269   
        crate::operation::publish_layer_version::builders::PublishLayerVersionInputBuilder::default()
  259    270   
    }
  260    271   
}
  261    272   
  262    273   
/// A builder for [`PublishLayerVersionInput`](crate::operation::publish_layer_version::PublishLayerVersionInput).
  263    274   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  264    275   
#[non_exhaustive]

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

@@ -54,54 +209,217 @@
   74     74   
    "com.amazonaws.lambda.synthetic",
   75     75   
    "PublishLayerVersionOutput",
   76     76   
);
   77     77   
static PUBLISHLAYERVERSIONOUTPUT_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionOutput$Content",
   80     80   
        "com.amazonaws.lambda.synthetic",
   81     81   
        "PublishLayerVersionOutput",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::Structure,
   84         -
    "content",
          84  +
    "Content",
   85     85   
    0,
   86     86   
);
   87     87   
static PUBLISHLAYERVERSIONOUTPUT_MEMBER_LAYER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionOutput$LayerArn",
   90     90   
        "com.amazonaws.lambda.synthetic",
   91     91   
        "PublishLayerVersionOutput",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "layer_arn",
          94  +
    "LayerArn",
   95     95   
    1,
   96     96   
);
   97     97   
static PUBLISHLAYERVERSIONOUTPUT_MEMBER_LAYER_VERSION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionOutput$LayerVersionArn",
  100    100   
        "com.amazonaws.lambda.synthetic",
  101    101   
        "PublishLayerVersionOutput",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::String,
  104         -
    "layer_version_arn",
         104  +
    "LayerVersionArn",
  105    105   
    2,
  106    106   
);
  107    107   
static PUBLISHLAYERVERSIONOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionOutput$Description",
  110    110   
        "com.amazonaws.lambda.synthetic",
  111    111   
        "PublishLayerVersionOutput",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "description",
         114  +
    "Description",
  115    115   
    3,
  116    116   
);
  117    117   
static PUBLISHLAYERVERSIONOUTPUT_MEMBER_CREATED_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionOutput$CreatedDate",
  120    120   
        "com.amazonaws.lambda.synthetic",
  121    121   
        "PublishLayerVersionOutput",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "created_date",
         124  +
    "CreatedDate",
  125    125   
    4,
  126    126   
);
  127    127   
static PUBLISHLAYERVERSIONOUTPUT_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionOutput$Version",
  130    130   
        "com.amazonaws.lambda.synthetic",
  131    131   
        "PublishLayerVersionOutput",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::Long,
  134         -
    "version",
         134  +
    "Version",
  135    135   
    5,
  136    136   
);
  137    137   
static PUBLISHLAYERVERSIONOUTPUT_MEMBER_COMPATIBLE_RUNTIMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionOutput$CompatibleRuntimes",
  140    140   
        "com.amazonaws.lambda.synthetic",
  141    141   
        "PublishLayerVersionOutput",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::List,
  144         -
    "compatible_runtimes",
         144  +
    "CompatibleRuntimes",
  145    145   
    6,
  146    146   
);
  147    147   
static PUBLISHLAYERVERSIONOUTPUT_MEMBER_LICENSE_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static(
  149    149   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionOutput$LicenseInfo",
  150    150   
        "com.amazonaws.lambda.synthetic",
  151    151   
        "PublishLayerVersionOutput",
  152    152   
    ),
  153    153   
    ::aws_smithy_schema::ShapeType::String,
  154         -
    "license_info",
         154  +
    "LicenseInfo",
  155    155   
    7,
  156    156   
);
  157    157   
static PUBLISHLAYERVERSIONOUTPUT_MEMBER_COMPATIBLE_ARCHITECTURES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static(
  159    159   
        "com.amazonaws.lambda.synthetic#PublishLayerVersionOutput$CompatibleArchitectures",
  160    160   
        "com.amazonaws.lambda.synthetic",
  161    161   
        "PublishLayerVersionOutput",
  162    162   
    ),
  163    163   
    ::aws_smithy_schema::ShapeType::List,
  164         -
    "compatible_architectures",
         164  +
    "CompatibleArchitectures",
  165    165   
    8,
  166    166   
);
         167  +
static PUBLISHLAYERVERSIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         168  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         169  +
    ::aws_smithy_schema::ShapeType::String,
         170  +
    "request_id",
         171  +
    9,
         172  +
)
         173  +
.with_http_header("x-amzn-requestid");
  167    174   
static PUBLISHLAYERVERSIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  168    175   
    PUBLISHLAYERVERSIONOUTPUT_SCHEMA_ID,
  169    176   
    ::aws_smithy_schema::ShapeType::Structure,
  170    177   
    &[
  171    178   
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER_CONTENT,
  172    179   
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER_LAYER_ARN,
  173    180   
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER_LAYER_VERSION_ARN,
  174    181   
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER_DESCRIPTION,
  175    182   
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER_CREATED_DATE,
  176    183   
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER_VERSION,
  177    184   
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER_COMPATIBLE_RUNTIMES,
  178    185   
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER_LICENSE_INFO,
  179    186   
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER_COMPATIBLE_ARCHITECTURES,
         187  +
        &PUBLISHLAYERVERSIONOUTPUT_MEMBER__REQUEST_ID,
  180    188   
    ],
  181    189   
);
  182    190   
impl PublishLayerVersionOutput {
  183    191   
    /// The schema for this shape.
  184    192   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUBLISHLAYERVERSIONOUTPUT_SCHEMA;
  185    193   
}
  186    194   
impl ::aws_smithy_schema::serde::SerializableStruct for PublishLayerVersionOutput {
  187    195   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  188    196   
    fn serialize_members(
  189    197   
        &self,
@@ -211,219 +329,406 @@
  231    239   
                    }
  232    240   
                    Ok(())
  233    241   
                },
  234    242   
            )?;
  235    243   
        }
  236    244   
        Ok(())
  237    245   
    }
  238    246   
}
  239    247   
impl PublishLayerVersionOutput {
  240    248   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  241         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  242         -
        deserializer: &mut D,
         249  +
    pub fn deserialize(
         250  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  243    251   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  244    252   
        #[allow(unused_variables, unused_mut)]
  245    253   
        let mut builder = Self::builder();
  246    254   
        #[allow(
  247    255   
            unused_variables,
  248    256   
            unreachable_code,
  249    257   
            clippy::single_match,
  250    258   
            clippy::match_single_binding,
  251    259   
            clippy::diverging_sub_expression
  252    260   
        )]
  253         -
        deserializer.read_struct(&PUBLISHLAYERVERSIONOUTPUT_SCHEMA, (), |_, member, deser| {
         261  +
        deserializer.read_struct(&PUBLISHLAYERVERSIONOUTPUT_SCHEMA, &mut |member, deser| {
  254    262   
            match member.member_index() {
  255    263   
                Some(0) => {
  256    264   
                    builder.content = Some(crate::types::LayerVersionContentOutput::deserialize(deser)?);
  257    265   
                }
  258    266   
                Some(1) => {
  259    267   
                    builder.layer_arn = Some(deser.read_string(member)?);
  260    268   
                }
  261    269   
                Some(2) => {
  262    270   
                    builder.layer_version_arn = Some(deser.read_string(member)?);
  263    271   
                }
  264    272   
                Some(3) => {
  265    273   
                    builder.description = Some(deser.read_string(member)?);
  266    274   
                }
  267    275   
                Some(4) => {
  268    276   
                    builder.created_date = Some(deser.read_string(member)?);
  269    277   
                }
  270    278   
                Some(5) => {
  271    279   
                    builder.version = Some(deser.read_long(member)?);
  272    280   
                }
  273    281   
                Some(6) => {
  274    282   
                    builder.compatible_runtimes = Some({
  275         -
                        let container = if let Some(cap) = deser.container_size() {
  276         -
                            Vec::with_capacity(cap)
  277         -
                        } else {
  278         -
                            Vec::new()
  279         -
                        };
  280         -
                        deser.read_list(member, container, |mut list, deser| {
  281         -
                            list.push(crate::types::Runtime::from(deser.read_string(member)?.as_str()));
  282         -
                            Ok(list)
  283         -
                        })?
         283  +
                        let mut container = Vec::new();
         284  +
                        deser.read_list(member, &mut |deser| {
         285  +
                            container.push(crate::types::Runtime::from(deser.read_string(member)?.as_str()));
         286  +
                            Ok(())
         287  +
                        })?;
         288  +
                        container
  284    289   
                    });
  285    290   
                }
  286    291   
                Some(7) => {
  287    292   
                    builder.license_info = Some(deser.read_string(member)?);
  288    293   
                }
  289    294   
                Some(8) => {
  290    295   
                    builder.compatible_architectures = Some({
  291         -
                        let container = if let Some(cap) = deser.container_size() {
  292         -
                            Vec::with_capacity(cap)
  293         -
                        } else {
  294         -
                            Vec::new()
  295         -
                        };
  296         -
                        deser.read_list(member, container, |mut list, deser| {
  297         -
                            list.push(crate::types::Architecture::from(deser.read_string(member)?.as_str()));
  298         -
                            Ok(list)
  299         -
                        })?
         296  +
                        let mut container = Vec::new();
         297  +
                        deser.read_list(member, &mut |deser| {
         298  +
                            container.push(crate::types::Architecture::from(deser.read_string(member)?.as_str()));
         299  +
                            Ok(())
         300  +
                        })?;
         301  +
                        container
         302  +
                    });
         303  +
                }
         304  +
                Some(9) => {
         305  +
                    builder._request_id = Some(deser.read_string(member)?);
         306  +
                }
         307  +
                _ => {}
         308  +
            }
         309  +
            Ok(())
         310  +
        })?;
         311  +
        Ok(builder.build())
         312  +
    }
         313  +
}
         314  +
impl PublishLayerVersionOutput {
         315  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         316  +
    /// Header-bound members are read directly from headers, avoiding runtime
         317  +
    /// member iteration overhead. Body members are read via the deserializer.
         318  +
    pub fn deserialize_with_response(
         319  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         320  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         321  +
        _status: u16,
         322  +
        _body: &[u8],
         323  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         324  +
        #[allow(unused_variables, unused_mut)]
         325  +
        let mut builder = Self::builder();
         326  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         327  +
            builder._request_id = Some(val.to_string());
         328  +
        }
         329  +
        #[allow(
         330  +
            unused_variables,
         331  +
            unreachable_code,
         332  +
            clippy::single_match,
         333  +
            clippy::match_single_binding,
         334  +
            clippy::diverging_sub_expression
         335  +
        )]
         336  +
        deserializer.read_struct(&PUBLISHLAYERVERSIONOUTPUT_SCHEMA, &mut |member, deser| {
         337  +
            match member.member_index() {
         338  +
                Some(0) => {
         339  +
                    builder.content = Some(crate::types::LayerVersionContentOutput::deserialize(deser)?);
         340  +
                }
         341  +
                Some(1) => {
         342  +
                    builder.layer_arn = Some(deser.read_string(member)?);
         343  +
                }
         344  +
                Some(2) => {
         345  +
                    builder.layer_version_arn = Some(deser.read_string(member)?);
         346  +
                }
         347  +
                Some(3) => {
         348  +
                    builder.description = Some(deser.read_string(member)?);
         349  +
                }
         350  +
                Some(4) => {
         351  +
                    builder.created_date = Some(deser.read_string(member)?);
         352  +
                }
         353  +
                Some(5) => {
         354  +
                    builder.version = Some(deser.read_long(member)?);
         355  +
                }
         356  +
                Some(6) => {
         357  +
                    builder.compatible_runtimes = Some({
         358  +
                        let mut container = Vec::new();
         359  +
                        deser.read_list(member, &mut |deser| {
         360  +
                            container.push(crate::types::Runtime::from(deser.read_string(member)?.as_str()));
         361  +
                            Ok(())
         362  +
                        })?;
         363  +
                        container
         364  +
                    });
         365  +
                }
         366  +
                Some(7) => {
         367  +
                    builder.license_info = Some(deser.read_string(member)?);
         368  +
                }
         369  +
                Some(8) => {
         370  +
                    builder.compatible_architectures = Some({
         371  +
                        let mut container = Vec::new();
         372  +
                        deser.read_list(member, &mut |deser| {
         373  +
                            container.push(crate::types::Architecture::from(deser.read_string(member)?.as_str()));
         374  +
                            Ok(())
         375  +
                        })?;
         376  +
                        container
  300    377   
                    });
  301    378   
                }
  302    379   
                _ => {}
  303    380   
            }
  304    381   
            Ok(())
  305    382   
        })?;
  306    383   
        Ok(builder.build())
  307    384   
    }
  308    385   
}
  309    386   
impl ::aws_types::request_id::RequestId for PublishLayerVersionOutput {

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/publish_version.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 `PublishVersion`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct PublishVersion;
    6      6   
impl PublishVersion {
    7      7   
    /// Creates a new `PublishVersion`
    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::publish_version::PublishVersionInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::publish_version::PublishVersionOutput::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::publish_version::PublishVersionInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::publish_version::PublishVersionOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::publish_version::PublishVersionError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -119,123 +250,458 @@
  139    143   
        ::std::borrow::Cow::Owned(rcb)
  140    144   
    }
  141    145   
}
  142    146   
  143    147   
#[derive(Debug)]
  144    148   
struct PublishVersionResponseDeserializer;
  145    149   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PublishVersionResponseDeserializer {
  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 != 201 || force_error {
  157         -
            crate::protocol_serde::shape_publish_version::de_publish_version_http_error(status, headers, body)
  158         -
        } else {
  159         -
            crate::protocol_serde::shape_publish_version::de_publish_version_http_response(status, headers, body)
         159  +
        if !success && status != 201 || 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::publish_version::PublishVersionError::unhandled(
         173  +
                            generic,
         174  +
                        )),
         175  +
                    ))
         176  +
                }
         177  +
            };
         178  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         179  +
            let protocol = _cfg
         180  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         181  +
                .expect("a SharedClientProtocol is required");
         182  +
            let err = match error_code {
         183  +
                "CodeStorageExceededException" => crate::operation::publish_version::PublishVersionError::CodeStorageExceededException({
         184  +
                    let mut tmp = match protocol
         185  +
                        .deserialize_response(response, crate::types::error::CodeStorageExceededException::SCHEMA, _cfg)
         186  +
                        .and_then(|mut deser| {
         187  +
                            crate::types::error::CodeStorageExceededException::deserialize_with_response(
         188  +
                                &mut *deser,
         189  +
                                response.headers(),
         190  +
                                response.status().into(),
         191  +
                                body,
         192  +
                            )
         193  +
                        }) {
         194  +
                        ::std::result::Result::Ok(val) => val,
         195  +
                        ::std::result::Result::Err(e) => {
         196  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         197  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         198  +
                            ))
         199  +
                        }
         200  +
                    };
         201  +
                    tmp.meta = generic;
         202  +
                    if tmp.message.is_none() {
         203  +
                        tmp.message = _error_message;
         204  +
                    }
         205  +
                    tmp
         206  +
                }),
         207  +
                "InvalidParameterValueException" => crate::operation::publish_version::PublishVersionError::InvalidParameterValueException({
         208  +
                    let mut tmp = match protocol
         209  +
                        .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
         210  +
                        .and_then(|mut deser| {
         211  +
                            crate::types::error::InvalidParameterValueException::deserialize_with_response(
         212  +
                                &mut *deser,
         213  +
                                response.headers(),
         214  +
                                response.status().into(),
         215  +
                                body,
         216  +
                            )
         217  +
                        }) {
         218  +
                        ::std::result::Result::Ok(val) => val,
         219  +
                        ::std::result::Result::Err(e) => {
         220  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         221  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         222  +
                            ))
         223  +
                        }
         224  +
                    };
         225  +
                    tmp.meta = generic;
         226  +
                    if tmp.message.is_none() {
         227  +
                        tmp.message = _error_message;
         228  +
                    }
         229  +
                    tmp
         230  +
                }),
         231  +
                "PreconditionFailedException" => crate::operation::publish_version::PublishVersionError::PreconditionFailedException({
         232  +
                    let mut tmp = match protocol
         233  +
                        .deserialize_response(response, crate::types::error::PreconditionFailedException::SCHEMA, _cfg)
         234  +
                        .and_then(|mut deser| {
         235  +
                            crate::types::error::PreconditionFailedException::deserialize_with_response(
         236  +
                                &mut *deser,
         237  +
                                response.headers(),
         238  +
                                response.status().into(),
         239  +
                                body,
         240  +
                            )
         241  +
                        }) {
         242  +
                        ::std::result::Result::Ok(val) => val,
         243  +
                        ::std::result::Result::Err(e) => {
         244  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         245  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         246  +
                            ))
         247  +
                        }
         248  +
                    };
         249  +
                    tmp.meta = generic;
         250  +
                    if tmp.message.is_none() {
         251  +
                        tmp.message = _error_message;
         252  +
                    }
         253  +
                    tmp
         254  +
                }),
         255  +
                "ResourceConflictException" => crate::operation::publish_version::PublishVersionError::ResourceConflictException({
         256  +
                    let mut tmp = match protocol
         257  +
                        .deserialize_response(response, crate::types::error::ResourceConflictException::SCHEMA, _cfg)
         258  +
                        .and_then(|mut deser| {
         259  +
                            crate::types::error::ResourceConflictException::deserialize_with_response(
         260  +
                                &mut *deser,
         261  +
                                response.headers(),
         262  +
                                response.status().into(),
         263  +
                                body,
         264  +
                            )
         265  +
                        }) {
         266  +
                        ::std::result::Result::Ok(val) => val,
         267  +
                        ::std::result::Result::Err(e) => {
         268  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         269  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         270  +
                            ))
         271  +
                        }
         272  +
                    };
         273  +
                    tmp.meta = generic;
         274  +
                    if tmp.message.is_none() {
         275  +
                        tmp.message = _error_message;
         276  +
                    }
         277  +
                    tmp
         278  +
                }),
         279  +
                "ResourceNotFoundException" => crate::operation::publish_version::PublishVersionError::ResourceNotFoundException({
         280  +
                    let mut tmp = match protocol
         281  +
                        .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
         282  +
                        .and_then(|mut deser| {
         283  +
                            crate::types::error::ResourceNotFoundException::deserialize_with_response(
         284  +
                                &mut *deser,
         285  +
                                response.headers(),
         286  +
                                response.status().into(),
         287  +
                                body,
         288  +
                            )
         289  +
                        }) {
         290  +
                        ::std::result::Result::Ok(val) => val,
         291  +
                        ::std::result::Result::Err(e) => {
         292  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         293  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         294  +
                            ))
         295  +
                        }
         296  +
                    };
         297  +
                    tmp.meta = generic;
         298  +
                    if tmp.message.is_none() {
         299  +
                        tmp.message = _error_message;
         300  +
                    }
         301  +
                    tmp
         302  +
                }),
         303  +
                "ServiceException" => crate::operation::publish_version::PublishVersionError::ServiceException({
         304  +
                    let mut tmp = match protocol
         305  +
                        .deserialize_response(response, crate::types::error::ServiceException::SCHEMA, _cfg)
         306  +
                        .and_then(|mut deser| {
         307  +
                            crate::types::error::ServiceException::deserialize_with_response(
         308  +
                                &mut *deser,
         309  +
                                response.headers(),
         310  +
                                response.status().into(),
         311  +
                                body,
         312  +
                            )
         313  +
                        }) {
         314  +
                        ::std::result::Result::Ok(val) => val,
         315  +
                        ::std::result::Result::Err(e) => {
         316  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         317  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         318  +
                            ))
         319  +
                        }
         320  +
                    };
         321  +
                    tmp.meta = generic;
         322  +
                    if tmp.message.is_none() {
         323  +
                        tmp.message = _error_message;
         324  +
                    }
         325  +
                    tmp
         326  +
                }),
         327  +
                "TooManyRequestsException" => crate::operation::publish_version::PublishVersionError::TooManyRequestsException({
         328  +
                    let mut tmp = match protocol
         329  +
                        .deserialize_response(response, crate::types::error::TooManyRequestsException::SCHEMA, _cfg)
         330  +
                        .and_then(|mut deser| {
         331  +
                            crate::types::error::TooManyRequestsException::deserialize_with_response(
         332  +
                                &mut *deser,
         333  +
                                response.headers(),
         334  +
                                response.status().into(),
         335  +
                                body,
         336  +
                            )
         337  +
                        }) {
         338  +
                        ::std::result::Result::Ok(val) => val,
         339  +
                        ::std::result::Result::Err(e) => {
         340  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         341  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         342  +
                            ))
         343  +
                        }
  160    344   
                    };
  161         -
        crate::protocol_serde::type_erase_result(parse_result)
         345  +
                    tmp.meta = generic;
         346  +
                    if tmp.message.is_none() {
         347  +
                        tmp.message = _error_message;
         348  +
                    }
         349  +
                    tmp
         350  +
                }),
         351  +
                _ => crate::operation::publish_version::PublishVersionError::generic(generic),
         352  +
            };
         353  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         354  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         355  +
            ))
         356  +
        } else {
         357  +
            let protocol = _cfg
         358  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         359  +
                .expect("a SharedClientProtocol is required");
         360  +
            let mut deser = protocol
         361  +
                .deserialize_response(response, PublishVersion::OUTPUT_SCHEMA, _cfg)
         362  +
                .map_err(|e| {
         363  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         364  +
                })?;
         365  +
            let body = response.body().bytes().expect("body loaded");
         366  +
            let output = crate::operation::publish_version::PublishVersionOutput::deserialize_with_response(
         367  +
                &mut *deser,
         368  +
                response.headers(),
         369  +
                response.status().into(),
         370  +
                body,
         371  +
            )
         372  +
            .map_err(|e| {
         373  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         374  +
            })?;
         375  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         376  +
        }
  162    377   
    }
  163    378   
}
  164    379   
#[derive(Debug)]
  165    380   
struct PublishVersionRequestSerializer;
  166    381   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PublishVersionRequestSerializer {
  167    382   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  168    383   
    fn serialize_input(
  169    384   
        &self,
  170    385   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  171    386   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  172    387   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  173    388   
        let input = input
  174    389   
            .downcast::<crate::operation::publish_version::PublishVersionInput>()
  175    390   
            .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::publish_version::PublishVersionInput,
  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         -
                    ));
         391  +
        let protocol = _cfg
         392  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         393  +
            .expect("a SharedClientProtocol is required");
         394  +
        if protocol.supports_http_bindings() {
         395  +
            let mut request = protocol
         396  +
                .serialize_body(&input, PublishVersion::INPUT_SCHEMA, "", _cfg)
         397  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         398  +
            {
         399  +
                let mut uri = "/2015-03-31/functions/{FunctionName}/versions".to_string();
         400  +
                let mut query_params: Vec<(String, String)> = Vec::new();
         401  +
                if let Some(ref val) = input.function_name {
         402  +
                    uri = uri.replace("{FunctionName}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
         403  +
                }
         404  +
                if !query_params.is_empty() {
         405  +
                    uri.push(if uri.contains('?') { '&' } else { '?' });
         406  +
                    let pairs: Vec<String> = query_params
         407  +
                        .iter()
         408  +
                        .map(|(k, v)| {
         409  +
                            format!(
         410  +
                                "{}={}",
         411  +
                                ::aws_smithy_schema::http_protocol::percent_encode(k),
         412  +
                                ::aws_smithy_schema::http_protocol::percent_encode(v)
         413  +
                            )
         414  +
                        })
         415  +
                        .collect();
         416  +
                    uri.push_str(&pairs.join("&"));
  197    417   
                }
  198         -
                ::std::write!(output, "/2015-03-31/functions/{FunctionName}/versions", FunctionName = function_name)
  199         -
                    .expect("formatting should succeed");
  200         -
                ::std::result::Result::Ok(())
         418  +
                request.set_uri(uri.as_str()).expect("valid URI");
  201    419   
            }
  202         -
            #[allow(clippy::unnecessary_wraps)]
  203         -
            fn update_http_builder(
  204         -
                input: &crate::operation::publish_version::PublishVersionInput,
  205         -
                builder: ::http_1x::request::Builder,
  206         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  207         -
                let mut uri = ::std::string::String::new();
  208         -
                uri_base(input, &mut uri)?;
  209         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  210         -
            }
  211         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  212         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  213         -
            builder
  214         -
        };
  215         -
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_publish_version::ser_publish_version_input(&input)?);
  216         -
        if let Some(content_length) = body.content_length() {
  217         -
            let content_length = content_length.to_string();
  218         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
         420  +
         421  +
            return ::std::result::Result::Ok(request);
         422  +
        } else {
         423  +
            let mut request = protocol
         424  +
                .serialize_request(&input, PublishVersion::INPUT_SCHEMA, "", _cfg)
         425  +
                .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         426  +
         427  +
            return ::std::result::Result::Ok(request);
  219    428   
        }
  220         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  221    429   
    }
  222    430   
}
  223    431   
#[derive(Debug)]
  224    432   
struct PublishVersionEndpointParamsInterceptor;
  225    433   
  226    434   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PublishVersionEndpointParamsInterceptor {
  227    435   
    fn name(&self) -> &'static str {
  228    436   
        "PublishVersionEndpointParamsInterceptor"
  229    437   
    }
  230    438

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

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

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

@@ -241,241 +693,701 @@
  261    261   
    "com.amazonaws.lambda.synthetic",
  262    262   
    "PublishVersionOutput",
  263    263   
);
  264    264   
static PUBLISHVERSIONOUTPUT_MEMBER_FUNCTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  265    265   
    ::aws_smithy_schema::ShapeId::from_static(
  266    266   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$FunctionName",
  267    267   
        "com.amazonaws.lambda.synthetic",
  268    268   
        "PublishVersionOutput",
  269    269   
    ),
  270    270   
    ::aws_smithy_schema::ShapeType::String,
  271         -
    "function_name",
         271  +
    "FunctionName",
  272    272   
    0,
  273    273   
);
  274    274   
static PUBLISHVERSIONOUTPUT_MEMBER_FUNCTION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  275    275   
    ::aws_smithy_schema::ShapeId::from_static(
  276    276   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$FunctionArn",
  277    277   
        "com.amazonaws.lambda.synthetic",
  278    278   
        "PublishVersionOutput",
  279    279   
    ),
  280    280   
    ::aws_smithy_schema::ShapeType::String,
  281         -
    "function_arn",
         281  +
    "FunctionArn",
  282    282   
    1,
  283    283   
);
  284    284   
static PUBLISHVERSIONOUTPUT_MEMBER_RUNTIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  285    285   
    ::aws_smithy_schema::ShapeId::from_static(
  286    286   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$Runtime",
  287    287   
        "com.amazonaws.lambda.synthetic",
  288    288   
        "PublishVersionOutput",
  289    289   
    ),
  290    290   
    ::aws_smithy_schema::ShapeType::String,
  291         -
    "runtime",
         291  +
    "Runtime",
  292    292   
    2,
  293    293   
);
  294    294   
static PUBLISHVERSIONOUTPUT_MEMBER_ROLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  295    295   
    ::aws_smithy_schema::ShapeId::from_static(
  296    296   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$Role",
  297    297   
        "com.amazonaws.lambda.synthetic",
  298    298   
        "PublishVersionOutput",
  299    299   
    ),
  300    300   
    ::aws_smithy_schema::ShapeType::String,
  301         -
    "role",
         301  +
    "Role",
  302    302   
    3,
  303    303   
);
  304    304   
static PUBLISHVERSIONOUTPUT_MEMBER_HANDLER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  305    305   
    ::aws_smithy_schema::ShapeId::from_static(
  306    306   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$Handler",
  307    307   
        "com.amazonaws.lambda.synthetic",
  308    308   
        "PublishVersionOutput",
  309    309   
    ),
  310    310   
    ::aws_smithy_schema::ShapeType::String,
  311         -
    "handler",
         311  +
    "Handler",
  312    312   
    4,
  313    313   
);
  314    314   
static PUBLISHVERSIONOUTPUT_MEMBER_CODE_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  315    315   
    ::aws_smithy_schema::ShapeId::from_static(
  316    316   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$CodeSize",
  317    317   
        "com.amazonaws.lambda.synthetic",
  318    318   
        "PublishVersionOutput",
  319    319   
    ),
  320    320   
    ::aws_smithy_schema::ShapeType::Long,
  321         -
    "code_size",
         321  +
    "CodeSize",
  322    322   
    5,
  323    323   
);
  324    324   
static PUBLISHVERSIONOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  325    325   
    ::aws_smithy_schema::ShapeId::from_static(
  326    326   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$Description",
  327    327   
        "com.amazonaws.lambda.synthetic",
  328    328   
        "PublishVersionOutput",
  329    329   
    ),
  330    330   
    ::aws_smithy_schema::ShapeType::String,
  331         -
    "description",
         331  +
    "Description",
  332    332   
    6,
  333    333   
);
  334    334   
static PUBLISHVERSIONOUTPUT_MEMBER_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  335    335   
    ::aws_smithy_schema::ShapeId::from_static(
  336    336   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$Timeout",
  337    337   
        "com.amazonaws.lambda.synthetic",
  338    338   
        "PublishVersionOutput",
  339    339   
    ),
  340    340   
    ::aws_smithy_schema::ShapeType::Integer,
  341         -
    "timeout",
         341  +
    "Timeout",
  342    342   
    7,
  343    343   
);
  344    344   
static PUBLISHVERSIONOUTPUT_MEMBER_MEMORY_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  345    345   
    ::aws_smithy_schema::ShapeId::from_static(
  346    346   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$MemorySize",
  347    347   
        "com.amazonaws.lambda.synthetic",
  348    348   
        "PublishVersionOutput",
  349    349   
    ),
  350    350   
    ::aws_smithy_schema::ShapeType::Integer,
  351         -
    "memory_size",
         351  +
    "MemorySize",
  352    352   
    8,
  353    353   
);
  354    354   
static PUBLISHVERSIONOUTPUT_MEMBER_LAST_MODIFIED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  355    355   
    ::aws_smithy_schema::ShapeId::from_static(
  356    356   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$LastModified",
  357    357   
        "com.amazonaws.lambda.synthetic",
  358    358   
        "PublishVersionOutput",
  359    359   
    ),
  360    360   
    ::aws_smithy_schema::ShapeType::String,
  361         -
    "last_modified",
         361  +
    "LastModified",
  362    362   
    9,
  363    363   
);
  364    364   
static PUBLISHVERSIONOUTPUT_MEMBER_CODE_SHA256: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  365    365   
    ::aws_smithy_schema::ShapeId::from_static(
  366    366   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$CodeSha256",
  367    367   
        "com.amazonaws.lambda.synthetic",
  368    368   
        "PublishVersionOutput",
  369    369   
    ),
  370    370   
    ::aws_smithy_schema::ShapeType::String,
  371         -
    "code_sha256",
         371  +
    "CodeSha256",
  372    372   
    10,
  373    373   
);
  374    374   
static PUBLISHVERSIONOUTPUT_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  375    375   
    ::aws_smithy_schema::ShapeId::from_static(
  376    376   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$Version",
  377    377   
        "com.amazonaws.lambda.synthetic",
  378    378   
        "PublishVersionOutput",
  379    379   
    ),
  380    380   
    ::aws_smithy_schema::ShapeType::String,
  381         -
    "version",
         381  +
    "Version",
  382    382   
    11,
  383    383   
);
  384    384   
static PUBLISHVERSIONOUTPUT_MEMBER_VPC_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  385    385   
    ::aws_smithy_schema::ShapeId::from_static(
  386    386   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$VpcConfig",
  387    387   
        "com.amazonaws.lambda.synthetic",
  388    388   
        "PublishVersionOutput",
  389    389   
    ),
  390    390   
    ::aws_smithy_schema::ShapeType::Structure,
  391         -
    "vpc_config",
         391  +
    "VpcConfig",
  392    392   
    12,
  393    393   
);
  394    394   
static PUBLISHVERSIONOUTPUT_MEMBER_DEAD_LETTER_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  395    395   
    ::aws_smithy_schema::ShapeId::from_static(
  396    396   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$DeadLetterConfig",
  397    397   
        "com.amazonaws.lambda.synthetic",
  398    398   
        "PublishVersionOutput",
  399    399   
    ),
  400    400   
    ::aws_smithy_schema::ShapeType::Structure,
  401         -
    "dead_letter_config",
         401  +
    "DeadLetterConfig",
  402    402   
    13,
  403    403   
);
  404    404   
static PUBLISHVERSIONOUTPUT_MEMBER_ENVIRONMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  405    405   
    ::aws_smithy_schema::ShapeId::from_static(
  406    406   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$Environment",
  407    407   
        "com.amazonaws.lambda.synthetic",
  408    408   
        "PublishVersionOutput",
  409    409   
    ),
  410    410   
    ::aws_smithy_schema::ShapeType::Structure,
  411         -
    "environment",
         411  +
    "Environment",
  412    412   
    14,
  413    413   
);
  414    414   
static PUBLISHVERSIONOUTPUT_MEMBER_KMS_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  415    415   
    ::aws_smithy_schema::ShapeId::from_static(
  416    416   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$KMSKeyArn",
  417    417   
        "com.amazonaws.lambda.synthetic",
  418    418   
        "PublishVersionOutput",
  419    419   
    ),
  420    420   
    ::aws_smithy_schema::ShapeType::String,
  421         -
    "kms_key_arn",
         421  +
    "KMSKeyArn",
  422    422   
    15,
  423    423   
);
  424    424   
static PUBLISHVERSIONOUTPUT_MEMBER_TRACING_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  425    425   
    ::aws_smithy_schema::ShapeId::from_static(
  426    426   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$TracingConfig",
  427    427   
        "com.amazonaws.lambda.synthetic",
  428    428   
        "PublishVersionOutput",
  429    429   
    ),
  430    430   
    ::aws_smithy_schema::ShapeType::Structure,
  431         -
    "tracing_config",
         431  +
    "TracingConfig",
  432    432   
    16,
  433    433   
);
  434    434   
static PUBLISHVERSIONOUTPUT_MEMBER_MASTER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  435    435   
    ::aws_smithy_schema::ShapeId::from_static(
  436    436   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$MasterArn",
  437    437   
        "com.amazonaws.lambda.synthetic",
  438    438   
        "PublishVersionOutput",
  439    439   
    ),
  440    440   
    ::aws_smithy_schema::ShapeType::String,
  441         -
    "master_arn",
         441  +
    "MasterArn",
  442    442   
    17,
  443    443   
);
  444    444   
static PUBLISHVERSIONOUTPUT_MEMBER_REVISION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  445    445   
    ::aws_smithy_schema::ShapeId::from_static(
  446    446   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$RevisionId",
  447    447   
        "com.amazonaws.lambda.synthetic",
  448    448   
        "PublishVersionOutput",
  449    449   
    ),
  450    450   
    ::aws_smithy_schema::ShapeType::String,
  451         -
    "revision_id",
         451  +
    "RevisionId",
  452    452   
    18,
  453    453   
);
  454    454   
static PUBLISHVERSIONOUTPUT_MEMBER_LAYERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  455    455   
    ::aws_smithy_schema::ShapeId::from_static(
  456    456   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$Layers",
  457    457   
        "com.amazonaws.lambda.synthetic",
  458    458   
        "PublishVersionOutput",
  459    459   
    ),
  460    460   
    ::aws_smithy_schema::ShapeType::List,
  461         -
    "layers",
         461  +
    "Layers",
  462    462   
    19,
  463    463   
);
  464    464   
static PUBLISHVERSIONOUTPUT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  465    465   
    ::aws_smithy_schema::ShapeId::from_static(
  466    466   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$State",
  467    467   
        "com.amazonaws.lambda.synthetic",
  468    468   
        "PublishVersionOutput",
  469    469   
    ),
  470    470   
    ::aws_smithy_schema::ShapeType::String,
  471         -
    "state",
         471  +
    "State",
  472    472   
    20,
  473    473   
);
  474    474   
static PUBLISHVERSIONOUTPUT_MEMBER_STATE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  475    475   
    ::aws_smithy_schema::ShapeId::from_static(
  476    476   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$StateReason",
  477    477   
        "com.amazonaws.lambda.synthetic",
  478    478   
        "PublishVersionOutput",
  479    479   
    ),
  480    480   
    ::aws_smithy_schema::ShapeType::String,
  481         -
    "state_reason",
         481  +
    "StateReason",
  482    482   
    21,
  483    483   
);
  484    484   
static PUBLISHVERSIONOUTPUT_MEMBER_STATE_REASON_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  485    485   
    ::aws_smithy_schema::ShapeId::from_static(
  486    486   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$StateReasonCode",
  487    487   
        "com.amazonaws.lambda.synthetic",
  488    488   
        "PublishVersionOutput",
  489    489   
    ),
  490    490   
    ::aws_smithy_schema::ShapeType::String,
  491         -
    "state_reason_code",
         491  +
    "StateReasonCode",
  492    492   
    22,
  493    493   
);
  494    494   
static PUBLISHVERSIONOUTPUT_MEMBER_LAST_UPDATE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  495    495   
    ::aws_smithy_schema::ShapeId::from_static(
  496    496   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$LastUpdateStatus",
  497    497   
        "com.amazonaws.lambda.synthetic",
  498    498   
        "PublishVersionOutput",
  499    499   
    ),
  500    500   
    ::aws_smithy_schema::ShapeType::String,
  501         -
    "last_update_status",
         501  +
    "LastUpdateStatus",
  502    502   
    23,
  503    503   
);
  504    504   
static PUBLISHVERSIONOUTPUT_MEMBER_LAST_UPDATE_STATUS_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  505    505   
    ::aws_smithy_schema::ShapeId::from_static(
  506    506   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$LastUpdateStatusReason",
  507    507   
        "com.amazonaws.lambda.synthetic",
  508    508   
        "PublishVersionOutput",
  509    509   
    ),
  510    510   
    ::aws_smithy_schema::ShapeType::String,
  511         -
    "last_update_status_reason",
         511  +
    "LastUpdateStatusReason",
  512    512   
    24,
  513    513   
);
  514    514   
static PUBLISHVERSIONOUTPUT_MEMBER_LAST_UPDATE_STATUS_REASON_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  515    515   
    ::aws_smithy_schema::ShapeId::from_static(
  516    516   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$LastUpdateStatusReasonCode",
  517    517   
        "com.amazonaws.lambda.synthetic",
  518    518   
        "PublishVersionOutput",
  519    519   
    ),
  520    520   
    ::aws_smithy_schema::ShapeType::String,
  521         -
    "last_update_status_reason_code",
         521  +
    "LastUpdateStatusReasonCode",
  522    522   
    25,
  523    523   
);
  524    524   
static PUBLISHVERSIONOUTPUT_MEMBER_FILE_SYSTEM_CONFIGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  525    525   
    ::aws_smithy_schema::ShapeId::from_static(
  526    526   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$FileSystemConfigs",
  527    527   
        "com.amazonaws.lambda.synthetic",
  528    528   
        "PublishVersionOutput",
  529    529   
    ),
  530    530   
    ::aws_smithy_schema::ShapeType::List,
  531         -
    "file_system_configs",
         531  +
    "FileSystemConfigs",
  532    532   
    26,
  533    533   
);
  534    534   
static PUBLISHVERSIONOUTPUT_MEMBER_PACKAGE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  535    535   
    ::aws_smithy_schema::ShapeId::from_static(
  536    536   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$PackageType",
  537    537   
        "com.amazonaws.lambda.synthetic",
  538    538   
        "PublishVersionOutput",
  539    539   
    ),
  540    540   
    ::aws_smithy_schema::ShapeType::String,
  541         -
    "package_type",
         541  +
    "PackageType",
  542    542   
    27,
  543    543   
);
  544    544   
static PUBLISHVERSIONOUTPUT_MEMBER_IMAGE_CONFIG_RESPONSE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  545    545   
    ::aws_smithy_schema::ShapeId::from_static(
  546    546   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$ImageConfigResponse",
  547    547   
        "com.amazonaws.lambda.synthetic",
  548    548   
        "PublishVersionOutput",
  549    549   
    ),
  550    550   
    ::aws_smithy_schema::ShapeType::Structure,
  551         -
    "image_config_response",
         551  +
    "ImageConfigResponse",
  552    552   
    28,
  553    553   
);
  554    554   
static PUBLISHVERSIONOUTPUT_MEMBER_SIGNING_PROFILE_VERSION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  555    555   
    ::aws_smithy_schema::ShapeId::from_static(
  556    556   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$SigningProfileVersionArn",
  557    557   
        "com.amazonaws.lambda.synthetic",
  558    558   
        "PublishVersionOutput",
  559    559   
    ),
  560    560   
    ::aws_smithy_schema::ShapeType::String,
  561         -
    "signing_profile_version_arn",
         561  +
    "SigningProfileVersionArn",
  562    562   
    29,
  563    563   
);
  564    564   
static PUBLISHVERSIONOUTPUT_MEMBER_SIGNING_JOB_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  565    565   
    ::aws_smithy_schema::ShapeId::from_static(
  566    566   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$SigningJobArn",
  567    567   
        "com.amazonaws.lambda.synthetic",
  568    568   
        "PublishVersionOutput",
  569    569   
    ),
  570    570   
    ::aws_smithy_schema::ShapeType::String,
  571         -
    "signing_job_arn",
         571  +
    "SigningJobArn",
  572    572   
    30,
  573    573   
);
  574    574   
static PUBLISHVERSIONOUTPUT_MEMBER_ARCHITECTURES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  575    575   
    ::aws_smithy_schema::ShapeId::from_static(
  576    576   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$Architectures",
  577    577   
        "com.amazonaws.lambda.synthetic",
  578    578   
        "PublishVersionOutput",
  579    579   
    ),
  580    580   
    ::aws_smithy_schema::ShapeType::List,
  581         -
    "architectures",
         581  +
    "Architectures",
  582    582   
    31,
  583    583   
);
  584    584   
static PUBLISHVERSIONOUTPUT_MEMBER_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  585    585   
    ::aws_smithy_schema::ShapeId::from_static(
  586    586   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$EphemeralStorage",
  587    587   
        "com.amazonaws.lambda.synthetic",
  588    588   
        "PublishVersionOutput",
  589    589   
    ),
  590    590   
    ::aws_smithy_schema::ShapeType::Structure,
  591         -
    "ephemeral_storage",
         591  +
    "EphemeralStorage",
  592    592   
    32,
  593    593   
);
  594    594   
static PUBLISHVERSIONOUTPUT_MEMBER_SNAP_START: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  595    595   
    ::aws_smithy_schema::ShapeId::from_static(
  596    596   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$SnapStart",
  597    597   
        "com.amazonaws.lambda.synthetic",
  598    598   
        "PublishVersionOutput",
  599    599   
    ),
  600    600   
    ::aws_smithy_schema::ShapeType::Structure,
  601         -
    "snap_start",
         601  +
    "SnapStart",
  602    602   
    33,
  603    603   
);
  604    604   
static PUBLISHVERSIONOUTPUT_MEMBER_RUNTIME_VERSION_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  605    605   
    ::aws_smithy_schema::ShapeId::from_static(
  606    606   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$RuntimeVersionConfig",
  607    607   
        "com.amazonaws.lambda.synthetic",
  608    608   
        "PublishVersionOutput",
  609    609   
    ),
  610    610   
    ::aws_smithy_schema::ShapeType::Structure,
  611         -
    "runtime_version_config",
         611  +
    "RuntimeVersionConfig",
  612    612   
    34,
  613    613   
);
  614    614   
static PUBLISHVERSIONOUTPUT_MEMBER_LOGGING_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  615    615   
    ::aws_smithy_schema::ShapeId::from_static(
  616    616   
        "com.amazonaws.lambda.synthetic#PublishVersionOutput$LoggingConfig",
  617    617   
        "com.amazonaws.lambda.synthetic",
  618    618   
        "PublishVersionOutput",
  619    619   
    ),
  620    620   
    ::aws_smithy_schema::ShapeType::Structure,
  621         -
    "logging_config",
         621  +
    "LoggingConfig",
  622    622   
    35,
  623    623   
);
         624  +
static PUBLISHVERSIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         625  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         626  +
    ::aws_smithy_schema::ShapeType::String,
         627  +
    "request_id",
         628  +
    36,
         629  +
)
         630  +
.with_http_header("x-amzn-requestid");
  624    631   
static PUBLISHVERSIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  625    632   
    PUBLISHVERSIONOUTPUT_SCHEMA_ID,
  626    633   
    ::aws_smithy_schema::ShapeType::Structure,
  627    634   
    &[
  628    635   
        &PUBLISHVERSIONOUTPUT_MEMBER_FUNCTION_NAME,
  629    636   
        &PUBLISHVERSIONOUTPUT_MEMBER_FUNCTION_ARN,
  630    637   
        &PUBLISHVERSIONOUTPUT_MEMBER_RUNTIME,
  631    638   
        &PUBLISHVERSIONOUTPUT_MEMBER_ROLE,
  632    639   
        &PUBLISHVERSIONOUTPUT_MEMBER_HANDLER,
  633    640   
        &PUBLISHVERSIONOUTPUT_MEMBER_CODE_SIZE,
  634    641   
        &PUBLISHVERSIONOUTPUT_MEMBER_DESCRIPTION,
  635    642   
        &PUBLISHVERSIONOUTPUT_MEMBER_TIMEOUT,
  636    643   
        &PUBLISHVERSIONOUTPUT_MEMBER_MEMORY_SIZE,
  637    644   
        &PUBLISHVERSIONOUTPUT_MEMBER_LAST_MODIFIED,
  638    645   
        &PUBLISHVERSIONOUTPUT_MEMBER_CODE_SHA256,
  639    646   
        &PUBLISHVERSIONOUTPUT_MEMBER_VERSION,
  640    647   
        &PUBLISHVERSIONOUTPUT_MEMBER_VPC_CONFIG,
  641    648   
        &PUBLISHVERSIONOUTPUT_MEMBER_DEAD_LETTER_CONFIG,
  642    649   
        &PUBLISHVERSIONOUTPUT_MEMBER_ENVIRONMENT,
  643    650   
        &PUBLISHVERSIONOUTPUT_MEMBER_KMS_KEY_ARN,
  644    651   
        &PUBLISHVERSIONOUTPUT_MEMBER_TRACING_CONFIG,
  645    652   
        &PUBLISHVERSIONOUTPUT_MEMBER_MASTER_ARN,
  646    653   
        &PUBLISHVERSIONOUTPUT_MEMBER_REVISION_ID,
  647    654   
        &PUBLISHVERSIONOUTPUT_MEMBER_LAYERS,
  648    655   
        &PUBLISHVERSIONOUTPUT_MEMBER_STATE,
  649    656   
        &PUBLISHVERSIONOUTPUT_MEMBER_STATE_REASON,
  650    657   
        &PUBLISHVERSIONOUTPUT_MEMBER_STATE_REASON_CODE,
  651    658   
        &PUBLISHVERSIONOUTPUT_MEMBER_LAST_UPDATE_STATUS,
  652    659   
        &PUBLISHVERSIONOUTPUT_MEMBER_LAST_UPDATE_STATUS_REASON,
  653    660   
        &PUBLISHVERSIONOUTPUT_MEMBER_LAST_UPDATE_STATUS_REASON_CODE,
  654    661   
        &PUBLISHVERSIONOUTPUT_MEMBER_FILE_SYSTEM_CONFIGS,
  655    662   
        &PUBLISHVERSIONOUTPUT_MEMBER_PACKAGE_TYPE,
  656    663   
        &PUBLISHVERSIONOUTPUT_MEMBER_IMAGE_CONFIG_RESPONSE,
  657    664   
        &PUBLISHVERSIONOUTPUT_MEMBER_SIGNING_PROFILE_VERSION_ARN,
  658    665   
        &PUBLISHVERSIONOUTPUT_MEMBER_SIGNING_JOB_ARN,
  659    666   
        &PUBLISHVERSIONOUTPUT_MEMBER_ARCHITECTURES,
  660    667   
        &PUBLISHVERSIONOUTPUT_MEMBER_EPHEMERAL_STORAGE,
  661    668   
        &PUBLISHVERSIONOUTPUT_MEMBER_SNAP_START,
  662    669   
        &PUBLISHVERSIONOUTPUT_MEMBER_RUNTIME_VERSION_CONFIG,
  663    670   
        &PUBLISHVERSIONOUTPUT_MEMBER_LOGGING_CONFIG,
         671  +
        &PUBLISHVERSIONOUTPUT_MEMBER__REQUEST_ID,
  664    672   
    ],
  665    673   
);
  666    674   
impl PublishVersionOutput {
  667    675   
    /// The schema for this shape.
  668    676   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUBLISHVERSIONOUTPUT_SCHEMA;
  669    677   
}
  670    678   
impl ::aws_smithy_schema::serde::SerializableStruct for PublishVersionOutput {
  671    679   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  672    680   
    fn serialize_members(
  673    681   
        &self,
@@ -784,792 +982,1145 @@
  804    812   
            ser.write_struct(&PUBLISHVERSIONOUTPUT_MEMBER_RUNTIME_VERSION_CONFIG, val)?;
  805    813   
        }
  806    814   
        if let Some(ref val) = self.logging_config {
  807    815   
            ser.write_struct(&PUBLISHVERSIONOUTPUT_MEMBER_LOGGING_CONFIG, val)?;
  808    816   
        }
  809    817   
        Ok(())
  810    818   
    }
  811    819   
}
  812    820   
impl PublishVersionOutput {
  813    821   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  814         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  815         -
        deserializer: &mut D,
         822  +
    pub fn deserialize(
         823  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         824  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         825  +
        #[allow(unused_variables, unused_mut)]
         826  +
        let mut builder = Self::builder();
         827  +
        #[allow(
         828  +
            unused_variables,
         829  +
            unreachable_code,
         830  +
            clippy::single_match,
         831  +
            clippy::match_single_binding,
         832  +
            clippy::diverging_sub_expression
         833  +
        )]
         834  +
        deserializer.read_struct(&PUBLISHVERSIONOUTPUT_SCHEMA, &mut |member, deser| {
         835  +
            match member.member_index() {
         836  +
                Some(0) => {
         837  +
                    builder.function_name = Some(deser.read_string(member)?);
         838  +
                }
         839  +
                Some(1) => {
         840  +
                    builder.function_arn = Some(deser.read_string(member)?);
         841  +
                }
         842  +
                Some(2) => {
         843  +
                    builder.runtime = Some(crate::types::Runtime::from(deser.read_string(member)?.as_str()));
         844  +
                }
         845  +
                Some(3) => {
         846  +
                    builder.role = Some(deser.read_string(member)?);
         847  +
                }
         848  +
                Some(4) => {
         849  +
                    builder.handler = Some(deser.read_string(member)?);
         850  +
                }
         851  +
                Some(5) => {
         852  +
                    builder.code_size = Some(deser.read_long(member)?);
         853  +
                }
         854  +
                Some(6) => {
         855  +
                    builder.description = Some(deser.read_string(member)?);
         856  +
                }
         857  +
                Some(7) => {
         858  +
                    builder.timeout = Some(deser.read_integer(member)?);
         859  +
                }
         860  +
                Some(8) => {
         861  +
                    builder.memory_size = Some(deser.read_integer(member)?);
         862  +
                }
         863  +
                Some(9) => {
         864  +
                    builder.last_modified = Some(deser.read_string(member)?);
         865  +
                }
         866  +
                Some(10) => {
         867  +
                    builder.code_sha256 = Some(deser.read_string(member)?);
         868  +
                }
         869  +
                Some(11) => {
         870  +
                    builder.version = Some(deser.read_string(member)?);
         871  +
                }
         872  +
                Some(12) => {
         873  +
                    builder.vpc_config = Some(crate::types::VpcConfigResponse::deserialize(deser)?);
         874  +
                }
         875  +
                Some(13) => {
         876  +
                    builder.dead_letter_config = Some(crate::types::DeadLetterConfig::deserialize(deser)?);
         877  +
                }
         878  +
                Some(14) => {
         879  +
                    builder.environment = Some(crate::types::EnvironmentResponse::deserialize(deser)?);
         880  +
                }
         881  +
                Some(15) => {
         882  +
                    builder.kms_key_arn = Some(deser.read_string(member)?);
         883  +
                }
         884  +
                Some(16) => {
         885  +
                    builder.tracing_config = Some(crate::types::TracingConfigResponse::deserialize(deser)?);
         886  +
                }
         887  +
                Some(17) => {
         888  +
                    builder.master_arn = Some(deser.read_string(member)?);
         889  +
                }
         890  +
                Some(18) => {
         891  +
                    builder.revision_id = Some(deser.read_string(member)?);
         892  +
                }
         893  +
                Some(19) => {
         894  +
                    builder.layers = Some({
         895  +
                        let mut container = Vec::new();
         896  +
                        deser.read_list(member, &mut |deser| {
         897  +
                            container.push(crate::types::Layer::deserialize(deser)?);
         898  +
                            Ok(())
         899  +
                        })?;
         900  +
                        container
         901  +
                    });
         902  +
                }
         903  +
                Some(20) => {
         904  +
                    builder.state = Some(crate::types::State::from(deser.read_string(member)?.as_str()));
         905  +
                }
         906  +
                Some(21) => {
         907  +
                    builder.state_reason = Some(deser.read_string(member)?);
         908  +
                }
         909  +
                Some(22) => {
         910  +
                    builder.state_reason_code = Some(crate::types::StateReasonCode::from(deser.read_string(member)?.as_str()));
         911  +
                }
         912  +
                Some(23) => {
         913  +
                    builder.last_update_status = Some(crate::types::LastUpdateStatus::from(deser.read_string(member)?.as_str()));
         914  +
                }
         915  +
                Some(24) => {
         916  +
                    builder.last_update_status_reason = Some(deser.read_string(member)?);
         917  +
                }
         918  +
                Some(25) => {
         919  +
                    builder.last_update_status_reason_code =
         920  +
                        Some(crate::types::LastUpdateStatusReasonCode::from(deser.read_string(member)?.as_str()));
         921  +
                }
         922  +
                Some(26) => {
         923  +
                    builder.file_system_configs = Some({
         924  +
                        let mut container = Vec::new();
         925  +
                        deser.read_list(member, &mut |deser| {
         926  +
                            container.push(crate::types::FileSystemConfig::deserialize(deser)?);
         927  +
                            Ok(())
         928  +
                        })?;
         929  +
                        container
         930  +
                    });
         931  +
                }
         932  +
                Some(27) => {
         933  +
                    builder.package_type = Some(crate::types::PackageType::from(deser.read_string(member)?.as_str()));
         934  +
                }
         935  +
                Some(28) => {
         936  +
                    builder.image_config_response = Some(crate::types::ImageConfigResponse::deserialize(deser)?);
         937  +
                }
         938  +
                Some(29) => {
         939  +
                    builder.signing_profile_version_arn = Some(deser.read_string(member)?);
         940  +
                }
         941  +
                Some(30) => {
         942  +
                    builder.signing_job_arn = Some(deser.read_string(member)?);
         943  +
                }
         944  +
                Some(31) => {
         945  +
                    builder.architectures = Some({
         946  +
                        let mut container = Vec::new();
         947  +
                        deser.read_list(member, &mut |deser| {
         948  +
                            container.push(crate::types::Architecture::from(deser.read_string(member)?.as_str()));
         949  +
                            Ok(())
         950  +
                        })?;
         951  +
                        container
         952  +
                    });
         953  +
                }
         954  +
                Some(32) => {
         955  +
                    builder.ephemeral_storage = Some(crate::types::EphemeralStorage::deserialize(deser)?);
         956  +
                }
         957  +
                Some(33) => {
         958  +
                    builder.snap_start = Some(crate::types::SnapStartResponse::deserialize(deser)?);
         959  +
                }
         960  +
                Some(34) => {
         961  +
                    builder.runtime_version_config = Some(crate::types::RuntimeVersionConfig::deserialize(deser)?);
         962  +
                }
         963  +
                Some(35) => {
         964  +
                    builder.logging_config = Some(crate::types::LoggingConfig::deserialize(deser)?);
         965  +
                }
         966  +
                Some(36) => {
         967  +
                    builder._request_id = Some(deser.read_string(member)?);
         968  +
                }
         969  +
                _ => {}
         970  +
            }
         971  +
            Ok(())
         972  +
        })?;
         973  +
        Ok(builder.build())
         974  +
    }
         975  +
}
         976  +
impl PublishVersionOutput {
         977  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         978  +
    /// Header-bound members are read directly from headers, avoiding runtime
         979  +
    /// member iteration overhead. Body members are read via the deserializer.
         980  +
    pub fn deserialize_with_response(
         981  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         982  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         983  +
        _status: u16,
         984  +
        _body: &[u8],
  816    985   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  817    986   
        #[allow(unused_variables, unused_mut)]
  818    987   
        let mut builder = Self::builder();
         988  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         989  +
            builder._request_id = Some(val.to_string());
         990  +
        }
  819    991   
        #[allow(
  820    992   
            unused_variables,
  821    993   
            unreachable_code,
  822    994   
            clippy::single_match,
  823    995   
            clippy::match_single_binding,
  824    996   
            clippy::diverging_sub_expression
  825    997   
        )]
  826         -
        deserializer.read_struct(&PUBLISHVERSIONOUTPUT_SCHEMA, (), |_, member, deser| {
         998  +
        deserializer.read_struct(&PUBLISHVERSIONOUTPUT_SCHEMA, &mut |member, deser| {
  827    999   
            match member.member_index() {
  828   1000   
                Some(0) => {
  829   1001   
                    builder.function_name = Some(deser.read_string(member)?);
  830   1002   
                }
  831   1003   
                Some(1) => {
  832   1004   
                    builder.function_arn = Some(deser.read_string(member)?);
  833   1005   
                }
  834   1006   
                Some(2) => {
  835   1007   
                    builder.runtime = Some(crate::types::Runtime::from(deser.read_string(member)?.as_str()));
  836   1008   
                }
  837   1009   
                Some(3) => {
  838   1010   
                    builder.role = Some(deser.read_string(member)?);
  839   1011   
                }
  840   1012   
                Some(4) => {
  841   1013   
                    builder.handler = Some(deser.read_string(member)?);
  842   1014   
                }
  843   1015   
                Some(5) => {
  844   1016   
                    builder.code_size = Some(deser.read_long(member)?);
  845   1017   
                }
  846   1018   
                Some(6) => {
  847   1019   
                    builder.description = Some(deser.read_string(member)?);
  848   1020   
                }
  849   1021   
                Some(7) => {
  850   1022   
                    builder.timeout = Some(deser.read_integer(member)?);
  851   1023   
                }
  852   1024   
                Some(8) => {
  853   1025   
                    builder.memory_size = Some(deser.read_integer(member)?);
  854   1026   
                }
  855   1027   
                Some(9) => {
  856   1028   
                    builder.last_modified = Some(deser.read_string(member)?);
  857   1029   
                }
  858   1030   
                Some(10) => {
  859   1031   
                    builder.code_sha256 = Some(deser.read_string(member)?);
  860   1032   
                }
  861   1033   
                Some(11) => {
  862   1034   
                    builder.version = Some(deser.read_string(member)?);
  863   1035   
                }
  864   1036   
                Some(12) => {
  865   1037   
                    builder.vpc_config = Some(crate::types::VpcConfigResponse::deserialize(deser)?);
  866   1038   
                }
  867   1039   
                Some(13) => {
  868   1040   
                    builder.dead_letter_config = Some(crate::types::DeadLetterConfig::deserialize(deser)?);
  869   1041   
                }
  870   1042   
                Some(14) => {
  871   1043   
                    builder.environment = Some(crate::types::EnvironmentResponse::deserialize(deser)?);
  872   1044   
                }
  873   1045   
                Some(15) => {
  874   1046   
                    builder.kms_key_arn = Some(deser.read_string(member)?);
  875   1047   
                }
  876   1048   
                Some(16) => {
  877   1049   
                    builder.tracing_config = Some(crate::types::TracingConfigResponse::deserialize(deser)?);
  878   1050   
                }
  879   1051   
                Some(17) => {
  880   1052   
                    builder.master_arn = Some(deser.read_string(member)?);
  881   1053   
                }
  882   1054   
                Some(18) => {
  883   1055   
                    builder.revision_id = Some(deser.read_string(member)?);
  884   1056   
                }
  885   1057   
                Some(19) => {
  886   1058   
                    builder.layers = Some({
  887         -
                        let container = if let Some(cap) = deser.container_size() {
  888         -
                            Vec::with_capacity(cap)
  889         -
                        } else {
  890         -
                            Vec::new()
  891         -
                        };
  892         -
                        deser.read_list(member, container, |mut list, deser| {
  893         -
                            list.push(crate::types::Layer::deserialize(deser)?);
  894         -
                            Ok(list)
  895         -
                        })?
        1059  +
                        let mut container = Vec::new();
        1060  +
                        deser.read_list(member, &mut |deser| {
        1061  +
                            container.push(crate::types::Layer::deserialize(deser)?);
        1062  +
                            Ok(())
        1063  +
                        })?;
        1064  +
                        container
  896   1065   
                    });
  897   1066   
                }
  898   1067   
                Some(20) => {
  899   1068   
                    builder.state = Some(crate::types::State::from(deser.read_string(member)?.as_str()));
  900   1069   
                }
  901   1070   
                Some(21) => {
  902   1071   
                    builder.state_reason = Some(deser.read_string(member)?);
  903   1072   
                }
  904   1073   
                Some(22) => {
  905   1074   
                    builder.state_reason_code = Some(crate::types::StateReasonCode::from(deser.read_string(member)?.as_str()));
  906   1075   
                }
  907   1076   
                Some(23) => {
  908   1077   
                    builder.last_update_status = Some(crate::types::LastUpdateStatus::from(deser.read_string(member)?.as_str()));
  909   1078   
                }
  910   1079   
                Some(24) => {
  911   1080   
                    builder.last_update_status_reason = Some(deser.read_string(member)?);
  912   1081   
                }
  913   1082   
                Some(25) => {
  914   1083   
                    builder.last_update_status_reason_code =
  915   1084   
                        Some(crate::types::LastUpdateStatusReasonCode::from(deser.read_string(member)?.as_str()));
  916   1085   
                }
  917   1086   
                Some(26) => {
  918   1087   
                    builder.file_system_configs = Some({
  919         -
                        let container = if let Some(cap) = deser.container_size() {
  920         -
                            Vec::with_capacity(cap)
  921         -
                        } else {
  922         -
                            Vec::new()
  923         -
                        };
  924         -
                        deser.read_list(member, container, |mut list, deser| {
  925         -
                            list.push(crate::types::FileSystemConfig::deserialize(deser)?);
  926         -
                            Ok(list)
  927         -
                        })?
        1088  +
                        let mut container = Vec::new();
        1089  +
                        deser.read_list(member, &mut |deser| {
        1090  +
                            container.push(crate::types::FileSystemConfig::deserialize(deser)?);
        1091  +
                            Ok(())
        1092  +
                        })?;
        1093  +
                        container
  928   1094   
                    });
  929   1095   
                }
  930   1096   
                Some(27) => {
  931   1097   
                    builder.package_type = Some(crate::types::PackageType::from(deser.read_string(member)?.as_str()));
  932   1098   
                }
  933   1099   
                Some(28) => {
  934   1100   
                    builder.image_config_response = Some(crate::types::ImageConfigResponse::deserialize(deser)?);
  935   1101   
                }
  936   1102   
                Some(29) => {
  937   1103   
                    builder.signing_profile_version_arn = Some(deser.read_string(member)?);
  938   1104   
                }
  939   1105   
                Some(30) => {
  940   1106   
                    builder.signing_job_arn = Some(deser.read_string(member)?);
  941   1107   
                }
  942   1108   
                Some(31) => {
  943   1109   
                    builder.architectures = Some({
  944         -
                        let container = if let Some(cap) = deser.container_size() {
  945         -
                            Vec::with_capacity(cap)
  946         -
                        } else {
  947         -
                            Vec::new()
  948         -
                        };
  949         -
                        deser.read_list(member, container, |mut list, deser| {
  950         -
                            list.push(crate::types::Architecture::from(deser.read_string(member)?.as_str()));
  951         -
                            Ok(list)
  952         -
                        })?
        1110  +
                        let mut container = Vec::new();
        1111  +
                        deser.read_list(member, &mut |deser| {
        1112  +
                            container.push(crate::types::Architecture::from(deser.read_string(member)?.as_str()));
        1113  +
                            Ok(())
        1114  +
                        })?;
        1115  +
                        container
  953   1116   
                    });
  954   1117   
                }
  955   1118   
                Some(32) => {
  956   1119   
                    builder.ephemeral_storage = Some(crate::types::EphemeralStorage::deserialize(deser)?);
  957   1120   
                }
  958   1121   
                Some(33) => {
  959   1122   
                    builder.snap_start = Some(crate::types::SnapStartResponse::deserialize(deser)?);
  960   1123   
                }
  961   1124   
                Some(34) => {
  962   1125   
                    builder.runtime_version_config = Some(crate::types::RuntimeVersionConfig::deserialize(deser)?);