AWS SDK

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

@@ -196,196 +263,263 @@

-196
+                }
                 ::std::write!(output, "/2015-03-31/functions/{FunctionName}/aliases", FunctionName = function_name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-200
+            }
             fn uri_query(
                 _input: &crate::operation::list_aliases::ListAliasesInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.function_version {
-207
+                    {
                         query.push_kv("FunctionVersion", &::aws_smithy_http::query::fmt_string(inner_2));
-209
+                    }
-210
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.marker {
-212
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_3));
-214
+                    }
-215
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.max_items {
-217
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-219
+                    }
-220
+                }
                 ::std::result::Result::Ok(())
-222
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_aliases::ListAliasesInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-232
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-237
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-239
+    }
-240
+}
 #[derive(Debug)]
 struct ListAliasesEndpointParamsInterceptor;
-243

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListAliasesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListAliasesEndpointParamsInterceptor"
-247
+    }
-248
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListAliasesInput>()
             .ok_or("failed to downcast to ListAliasesInput")?;
-263

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

@@ -182,182 +249,249 @@

↥ Expand context

         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_code_signing_configs::ListCodeSigningConfigsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/2020-04-22/code-signing-configs").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(
                 _input: &crate::operation::list_code_signing_configs::ListCodeSigningConfigsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_1) = &_input.marker {
-198
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }

                 if let ::std::option::Option::Some(inner_2) = &_input.max_items {
-203
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-205
+                    }
-206
+                }
                 ::std::result::Result::Ok(())
-208
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_code_signing_configs::ListCodeSigningConfigsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-218
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-223
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-225
+    }
-226
+}
 #[derive(Debug)]
 struct ListCodeSigningConfigsEndpointParamsInterceptor;
-229

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListCodeSigningConfigsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListCodeSigningConfigsEndpointParamsInterceptor"
-233
+    }
-234
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListCodeSigningConfigsInput>()
             .ok_or("failed to downcast to ListCodeSigningConfigsInput")?;
-249

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

@@ -192,192 +259,259 @@

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_event_source_mappings::ListEventSourceMappingsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_1) = &_input.event_source_arn {
-198
+                    {
                         query.push_kv("EventSourceArn", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.function_name {
-203
+                    {
                         query.push_kv("FunctionName", &::aws_smithy_http::query::fmt_string(inner_2));
-205
+                    }
-206
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.marker {
-208
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_3));
-210
+                    }
-211
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.max_items {
-213
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-215
+                    }
-216
+                }
                 ::std::result::Result::Ok(())
-218
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_event_source_mappings::ListEventSourceMappingsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-228
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-233
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-235
+    }
-236
+}
 #[derive(Debug)]
 struct ListEventSourceMappingsEndpointParamsInterceptor;
-239

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListEventSourceMappingsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListEventSourceMappingsEndpointParamsInterceptor"
-243
+    }
-244
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListEventSourceMappingsInput>()
             .ok_or("failed to downcast to ListEventSourceMappingsInput")?;
-259

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

@@ -206,206 +273,273 @@

↥ Expand context

                     ));
-207
+                }
                 ::std::write!(
                     output,
                     "/2019-09-25/functions/{FunctionName}/event-invoke-config/list",
                     FunctionName = function_name
-212
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-215
+            }
             fn uri_query(
                 _input: &crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.marker {
-222
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_2));
-224
+                    }
-225
+                }

                 if let ::std::option::Option::Some(inner_3) = &_input.max_items {
-227
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-229
+                    }
-230
+                }
                 ::std::result::Result::Ok(())
-232
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_function_event_invoke_configs::ListFunctionEventInvokeConfigsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-242
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-247
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-249
+    }
-250
+}
 #[derive(Debug)]
 struct ListFunctionEventInvokeConfigsEndpointParamsInterceptor;
-253

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListFunctionEventInvokeConfigsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListFunctionEventInvokeConfigsEndpointParamsInterceptor"
-257
+    }
-258
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListFunctionEventInvokeConfigsInput>()
             .ok_or("failed to downcast to ListFunctionEventInvokeConfigsInput")?;
-273

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

@@ -193,193 +260,260 @@

↥ Expand context

                 let function_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if function_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "function_name",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/2021-10-31/functions/{FunctionName}/urls", FunctionName = function_name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             fn uri_query(
                 _input: &crate::operation::list_function_url_configs::ListFunctionUrlConfigsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.marker {
-209
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_2));
-211
+                    }
-212
+                }

                 if let ::std::option::Option::Some(inner_3) = &_input.max_items {
-214
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-216
+                    }
-217
+                }
                 ::std::result::Result::Ok(())
-219
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_function_url_configs::ListFunctionUrlConfigsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-229
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-234
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-236
+    }
-237
+}
 #[derive(Debug)]
 struct ListFunctionUrlConfigsEndpointParamsInterceptor;
-240

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListFunctionUrlConfigsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListFunctionUrlConfigsEndpointParamsInterceptor"
-244
+    }
-245
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListFunctionUrlConfigsInput>()
             .ok_or("failed to downcast to ListFunctionUrlConfigsInput")?;
-260

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

@@ -190,190 +257,257 @@

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_functions::ListFunctionsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_1) = &_input.master_region {
-196
+                    {
                         query.push_kv("MasterRegion", &::aws_smithy_http::query::fmt_string(inner_1));
-198
+                    }
-199
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.function_version {
-201
+                    {
                         query.push_kv("FunctionVersion", &::aws_smithy_http::query::fmt_string(inner_2));
-203
+                    }
-204
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.marker {
-206
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_3));
-208
+                    }
-209
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.max_items {
-211
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-213
+                    }
-214
+                }
                 ::std::result::Result::Ok(())
-216
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_functions::ListFunctionsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-226
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-231
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-233
+    }
-234
+}
 #[derive(Debug)]
 struct ListFunctionsEndpointParamsInterceptor;
-237

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListFunctionsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListFunctionsEndpointParamsInterceptor"
-241
+    }
-242
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListFunctionsInput>()
             .ok_or("failed to downcast to ListFunctionsInput")?;
-257

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

@@ -208,208 +275,275 @@

↥ Expand context

                     ));
-209
+                }
                 ::std::write!(
                     output,
                     "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}/functions",
                     CodeSigningConfigArn = code_signing_config_arn
-214
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-217
+            }
             fn uri_query(
                 _input: &crate::operation::list_functions_by_code_signing_config::ListFunctionsByCodeSigningConfigInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.marker {
-224
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_2));
-226
+                    }
-227
+                }

                 if let ::std::option::Option::Some(inner_3) = &_input.max_items {
-229
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-231
+                    }
-232
+                }
                 ::std::result::Result::Ok(())
-234
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_functions_by_code_signing_config::ListFunctionsByCodeSigningConfigInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-244
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-249
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-251
+    }
-252
+}
 #[derive(Debug)]
 struct ListFunctionsByCodeSigningConfigEndpointParamsInterceptor;
-255

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListFunctionsByCodeSigningConfigEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListFunctionsByCodeSigningConfigEndpointParamsInterceptor"
-259
+    }
-260
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListFunctionsByCodeSigningConfigInput>()
             .ok_or("failed to downcast to ListFunctionsByCodeSigningConfigInput")?;
-275

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

@@ -203,203 +270,270 @@

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_layer_versions::ListLayerVersionsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.compatible_runtime {
-209
+                    {
                         query.push_kv("CompatibleRuntime", &::aws_smithy_http::query::fmt_string(inner_2));
-211
+                    }
-212
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.marker {
-214
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_3));
-216
+                    }
-217
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.max_items {
-219
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-221
+                    }
-222
+                }

                 if let ::std::option::Option::Some(inner_5) = &_input.compatible_architecture {
-224
+                    {
                         query.push_kv("CompatibleArchitecture", &::aws_smithy_http::query::fmt_string(inner_5));
-226
+                    }
-227
+                }
                 ::std::result::Result::Ok(())
-229
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_layer_versions::ListLayerVersionsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-239
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-244
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-246
+    }
-247
+}
 #[derive(Debug)]
 struct ListLayerVersionsEndpointParamsInterceptor;
-250

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListLayerVersionsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListLayerVersionsEndpointParamsInterceptor"
-254
+    }
-255
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListLayerVersionsInput>()
             .ok_or("failed to downcast to ListLayerVersionsInput")?;
-270

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

@@ -187,187 +254,254 @@

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_layers::ListLayersInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_1) = &_input.compatible_runtime {
-193
+                    {
                         query.push_kv("CompatibleRuntime", &::aws_smithy_http::query::fmt_string(inner_1));
-195
+                    }
-196
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.marker {
-198
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_2));
-200
+                    }
-201
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.max_items {
-203
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-205
+                    }
-206
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.compatible_architecture {
-208
+                    {
                         query.push_kv("CompatibleArchitecture", &::aws_smithy_http::query::fmt_string(inner_4));
-210
+                    }
-211
+                }
                 ::std::result::Result::Ok(())
-213
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_layers::ListLayersInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-223
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-228
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-230
+    }
-231
+}
 #[derive(Debug)]
 struct ListLayersEndpointParamsInterceptor;
-234

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListLayersEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListLayersEndpointParamsInterceptor"
-238
+    }
-239
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListLayersInput>()
             .ok_or("failed to downcast to ListLayersInput")?;
-254

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

@@ -209,209 +276,276 @@

↥ Expand context

-209
+                }
                 ::std::write!(
                     output,
                     "/2019-09-30/functions/{FunctionName}/provisioned-concurrency",
                     FunctionName = function_name
-214
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-217
+            }
             fn uri_query(
                 _input: &crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_kv("List", "ALL");
                 if let ::std::option::Option::Some(inner_2) = &_input.marker {
-225
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_2));
-227
+                    }
-228
+                }

                 if let ::std::option::Option::Some(inner_3) = &_input.max_items {
-230
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-232
+                    }
-233
+                }
                 ::std::result::Result::Ok(())
-235
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_provisioned_concurrency_configs::ListProvisionedConcurrencyConfigsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-245
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-250
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-252
+    }
-253
+}
 #[derive(Debug)]
 struct ListProvisionedConcurrencyConfigsEndpointParamsInterceptor;
-256

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListProvisionedConcurrencyConfigsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListProvisionedConcurrencyConfigsEndpointParamsInterceptor"
-260
+    }
-261
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListProvisionedConcurrencyConfigsInput>()
             .ok_or("failed to downcast to ListProvisionedConcurrencyConfigsInput")?;
-276

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

@@ -167,167 +233,233 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input.downcast::<crate::operation::list_tags::ListTagsInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_tags::ListTagsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.resource;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("resource", "cannot be empty or unset"))?;
                 let resource = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if resource.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "resource",
                         "cannot be empty or unset",
                     ));
-190
+                }
                 ::std::write!(output, "/2017-03-31/tags/{Resource}", Resource = resource).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-193
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_tags::ListTagsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-202
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-207
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-209
+    }
-210
+}
 #[derive(Debug)]
 struct ListTagsEndpointParamsInterceptor;
-213

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTagsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListTagsEndpointParamsInterceptor"
-217
+    }
-218
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListTagsInput>()
             .ok_or("failed to downcast to ListTagsInput")?;
-233

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

@@ -195,195 +262,262 @@

↥ Expand context

                 if function_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "function_name",
                         "cannot be empty or unset",
                     ));
-200
+                }
                 ::std::write!(output, "/2015-03-31/functions/{FunctionName}/versions", FunctionName = function_name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-204
+            }
             fn uri_query(
                 _input: &crate::operation::list_versions_by_function::ListVersionsByFunctionInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.marker {
-211
+                    {
                         query.push_kv("Marker", &::aws_smithy_http::query::fmt_string(inner_2));
-213
+                    }
-214
+                }

                 if let ::std::option::Option::Some(inner_3) = &_input.max_items {
-216
+                    {
                         query.push_kv("MaxItems", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-218
+                    }
-219
+                }
                 ::std::result::Result::Ok(())
-221
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_versions_by_function::ListVersionsByFunctionInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-231
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-236
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-238
+    }
-239
+}
 #[derive(Debug)]
 struct ListVersionsByFunctionEndpointParamsInterceptor;
-242

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListVersionsByFunctionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListVersionsByFunctionEndpointParamsInterceptor"
-246
+    }
-247
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListVersionsByFunctionInput>()
             .ok_or("failed to downcast to ListVersionsByFunctionInput")?;
-262

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

@@ -176,176 +251,251 @@

↥ Expand context

             .downcast::<crate::operation::publish_layer_version::PublishLayerVersionInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::publish_layer_version::PublishLayerVersionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.layer_name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("layer_name", "cannot be empty or unset"))?;
                 let layer_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if layer_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "layer_name",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/2018-10-31/layers/{LayerName}/versions", LayerName = layer_name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::publish_layer_version::PublishLayerVersionInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-211
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_publish_layer_version::ser_publish_layer_version_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-222
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-224
+    }
-225
+}
 #[derive(Debug)]
 struct PublishLayerVersionEndpointParamsInterceptor;
-228
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PublishLayerVersionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PublishLayerVersionEndpointParamsInterceptor"

↧ Expand context

-232
+    }
-233
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<PublishLayerVersionInput>()
             .ok_or("failed to downcast to PublishLayerVersionInput")?;
-248
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))

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

@@ -175,175 +248,248 @@

↥ Expand context

             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::publish_version::PublishVersionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.function_name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("function_name", "cannot be empty or unset"))?;
                 let function_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if function_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "function_name",

                         "cannot be empty or unset",
                     ));
-197
+                }
                 ::std::write!(output, "/2015-03-31/functions/{FunctionName}/versions", FunctionName = function_name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-201
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::publish_version::PublishVersionInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-210
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_publish_version::ser_publish_version_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-219
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-221
+    }
-222
+}
 #[derive(Debug)]
 struct PublishVersionEndpointParamsInterceptor;
-225
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PublishVersionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PublishVersionEndpointParamsInterceptor"

↧ Expand context

-229
+    }
-230
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<PublishVersionInput>()
             .ok_or("failed to downcast to PublishVersionInput")?;
-245
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))

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

@@ -187,187 +262,262 @@

↥ Expand context

             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.function_name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("function_name", "cannot be empty or unset"))?;
                 let function_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if function_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "function_name",
                         "cannot be empty or unset",
                     ));
-205
+                }
                 ::std::write!(

                     output,
                     "/2020-06-30/functions/{FunctionName}/code-signing-config",
                     FunctionName = function_name
-210
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-213
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_function_code_signing_config::PutFunctionCodeSigningConfigInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-222
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_put_function_code_signing_config::ser_put_function_code_signing_config_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-233
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-235
+    }
-236
+}
 #[derive(Debug)]
 struct PutFunctionCodeSigningConfigEndpointParamsInterceptor;
-239
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutFunctionCodeSigningConfigEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutFunctionCodeSigningConfigEndpointParamsInterceptor"

↧ Expand context

-243
+    }
-244
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<PutFunctionCodeSigningConfigInput>()
             .ok_or("failed to downcast to PutFunctionCodeSigningConfigInput")?;
-259
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))

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

@@ -177,177 +252,252 @@

↥ Expand context

             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::put_function_concurrency::PutFunctionConcurrencyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.function_name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("function_name", "cannot be empty or unset"))?;
                 let function_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if function_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "function_name",

                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/2017-10-31/functions/{FunctionName}/concurrency", FunctionName = function_name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-203
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_function_concurrency::PutFunctionConcurrencyInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-212
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_put_function_concurrency::ser_put_function_concurrency_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-223
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-225
+    }
-226
+}
 #[derive(Debug)]
 struct PutFunctionConcurrencyEndpointParamsInterceptor;
-229
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutFunctionConcurrencyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutFunctionConcurrencyEndpointParamsInterceptor"

↧ Expand context

-233
+    }
-234
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<PutFunctionConcurrencyInput>()
             .ok_or("failed to downcast to PutFunctionConcurrencyInput")?;
-249
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))

AWS SDK

Files changed: