AWS SDK

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

@@ -186,186 +253,253 @@

                 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}", FunctionName = function_name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-200
+            }
             fn uri_query(
                 _input: &crate::operation::get_function::GetFunctionInput,
                 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.qualifier {
-207
+                    {
                         query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
-209
+                    }
-210
+                }
                 ::std::result::Result::Ok(())
-212
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_function::GetFunctionInput,
                 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))
-222
+            }
             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("");
-227
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-229
+    }
-230
+}
 #[derive(Debug)]
 struct GetFunctionEndpointParamsInterceptor;
-233

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetFunctionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetFunctionEndpointParamsInterceptor"
-237
+    }
-238
     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::<GetFunctionInput>()
             .ok_or("failed to downcast to GetFunctionInput")?;
-253

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

@@ -187,187 +253,253 @@

↥ Expand context

             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_function_code_signing_config::GetFunctionCodeSigningConfigInput,
                 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::get_function_code_signing_config::GetFunctionCodeSigningConfigInput,
                 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))
-222
+            }
             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("");
-227
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-229
+    }
-230
+}
 #[derive(Debug)]
 struct GetFunctionCodeSigningConfigEndpointParamsInterceptor;
-233

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetFunctionCodeSigningConfigEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetFunctionCodeSigningConfigEndpointParamsInterceptor"
-237
+    }
-238
     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::<GetFunctionCodeSigningConfigInput>()
             .ok_or("failed to downcast to GetFunctionCodeSigningConfigInput")?;
-253

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

@@ -177,177 +243,243 @@

↥ 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::get_function_concurrency::GetFunctionConcurrencyInput,
                 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, "/2019-09-30/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::get_function_concurrency::GetFunctionConcurrencyInput,
                 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))
-212
+            }
             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("");
-217
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-219
+    }
-220
+}
 #[derive(Debug)]
 struct GetFunctionConcurrencyEndpointParamsInterceptor;
-223

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetFunctionConcurrencyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetFunctionConcurrencyEndpointParamsInterceptor"
-227
+    }
-228
     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::<GetFunctionConcurrencyInput>()
             .ok_or("failed to downcast to GetFunctionConcurrencyInput")?;
-243

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

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

↥ Expand context

                 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",
                     ));
-200
+                }
                 ::std::write!(output, "/2015-03-31/functions/{FunctionName}/configuration", FunctionName = function_name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-204
+            }
             fn uri_query(
                 _input: &crate::operation::get_function_configuration::GetFunctionConfigurationInput,
                 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.qualifier {
-211
+                    {
                         query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
-213
+                    }
-214
+                }
                 ::std::result::Result::Ok(())
-216
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_function_configuration::GetFunctionConfigurationInput,
                 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 GetFunctionConfigurationEndpointParamsInterceptor;
-237

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetFunctionConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetFunctionConfigurationEndpointParamsInterceptor"
-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::<GetFunctionConfigurationInput>()
             .ok_or("failed to downcast to GetFunctionConfigurationInput")?;
-257

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

@@ -199,199 +266,266 @@

↥ 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",
                     ));
-205
+                }
                 ::std::write!(
                     output,
                     "/2019-09-25/functions/{FunctionName}/event-invoke-config",
                     FunctionName = function_name
-210
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-213
+            }
             fn uri_query(
                 _input: &crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigInput,
                 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.qualifier {
-220
+                    {
                         query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
-222
+                    }
-223
+                }
                 ::std::result::Result::Ok(())
-225
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_function_event_invoke_config::GetFunctionEventInvokeConfigInput,
                 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))
-235
+            }
             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("");
-240
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-242
+    }
-243
+}
 #[derive(Debug)]
 struct GetFunctionEventInvokeConfigEndpointParamsInterceptor;
-246

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetFunctionEventInvokeConfigEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetFunctionEventInvokeConfigEndpointParamsInterceptor"
-250
+    }
-251
     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::<GetFunctionEventInvokeConfigInput>()
             .ok_or("failed to downcast to GetFunctionEventInvokeConfigInput")?;
-266

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

@@ -181,181 +247,247 @@

↥ Expand context

             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_function_recursion_config::GetFunctionRecursionConfigInput,
                 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,
                     "/2024-08-31/functions/{FunctionName}/recursion-config",
                     FunctionName = function_name
-204
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-207
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_function_recursion_config::GetFunctionRecursionConfigInput,
                 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))
-216
+            }
             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("");
-221
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-223
+    }
-224
+}
 #[derive(Debug)]
 struct GetFunctionRecursionConfigEndpointParamsInterceptor;
-227

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetFunctionRecursionConfigEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetFunctionRecursionConfigEndpointParamsInterceptor"
-231
+    }
-232
     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::<GetFunctionRecursionConfigInput>()
             .ok_or("failed to downcast to GetFunctionRecursionConfigInput")?;
-247

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

@@ -188,188 +255,255 @@

↥ Expand context

                 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, "/2021-10-31/functions/{FunctionName}/url", FunctionName = function_name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             fn uri_query(
                 _input: &crate::operation::get_function_url_config::GetFunctionUrlConfigInput,
                 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.qualifier {
-209
+                    {
                         query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
-211
+                    }
-212
+                }
                 ::std::result::Result::Ok(())
-214
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_function_url_config::GetFunctionUrlConfigInput,
                 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))
-224
+            }
             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("");
-229
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-231
+    }
-232
+}
 #[derive(Debug)]
 struct GetFunctionUrlConfigEndpointParamsInterceptor;
-235

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetFunctionUrlConfigEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetFunctionUrlConfigEndpointParamsInterceptor"
-239
+    }
-240
     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::<GetFunctionUrlConfigInput>()
             .ok_or("failed to downcast to GetFunctionUrlConfigInput")?;
-255

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

@@ -191,191 +257,257 @@

↥ Expand context

                 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",
                     ));
-196
+                }
                 let input_2 = &_input.version_number;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("version_number", "cannot be empty or unset"))?;
                 let mut version_number_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_2);
                 let version_number = version_number_encoder.encode();
                 if version_number.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "version_number",
                         "cannot be empty or unset",
                     ));
-208
+                }
                 ::std::write!(
                     output,

                     "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}",
                     LayerName = layer_name,
                     VersionNumber = version_number
-214
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-217
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_layer_version::GetLayerVersionInput,
                 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))
-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 GetLayerVersionEndpointParamsInterceptor;
-237

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetLayerVersionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetLayerVersionEndpointParamsInterceptor"
-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::<GetLayerVersionInput>()
             .ok_or("failed to downcast to GetLayerVersionInput")?;
-257

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

@@ -184,184 +251,251 @@

↥ Expand context

             fn uri_base(
                 _input: &crate::operation::get_layer_version_by_arn::GetLayerVersionByArnInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/2018-10-31/layers").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(
                 _input: &crate::operation::get_layer_version_by_arn::GetLayerVersionByArnInput,
                 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("find", "LayerVersion");
                 let inner_1 = &_input.arn;
                 let inner_1 = inner_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("arn", "cannot be empty or unset"))?;
                 if inner_1.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "arn",
                         "cannot be empty or unset",
                     ));
-207
+                }
                 query.push_kv("Arn", &::aws_smithy_http::query::fmt_string(inner_1));
                 ::std::result::Result::Ok(())
-210
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_layer_version_by_arn::GetLayerVersionByArnInput,
                 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))
-220
+            }
             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("");
-225
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-227
+    }
-228
+}
 #[derive(Debug)]
 struct GetLayerVersionByArnEndpointParamsInterceptor;
-231

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetLayerVersionByArnEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetLayerVersionByArnEndpointParamsInterceptor"
-235
+    }
-236
     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::<GetLayerVersionByArnInput>()
             .ok_or("failed to downcast to GetLayerVersionByArnInput")?;
-251

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

@@ -194,194 +260,260 @@

↥ Expand context

                 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
+                }
                 let input_2 = &_input.version_number;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("version_number", "cannot be empty or unset"))?;
                 let mut version_number_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_2);
                 let version_number = version_number_encoder.encode();
                 if version_number.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "version_number",
                         "cannot be empty or unset",
                     ));
-211
+                }
                 ::std::write!(
                     output,

                     "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy",
                     LayerName = layer_name,
                     VersionNumber = version_number
-217
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-220
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_layer_version_policy::GetLayerVersionPolicyInput,
                 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))
-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 GetLayerVersionPolicyEndpointParamsInterceptor;
-240

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetLayerVersionPolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetLayerVersionPolicyEndpointParamsInterceptor"
-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::<GetLayerVersionPolicyInput>()
             .ok_or("failed to downcast to GetLayerVersionPolicyInput")?;
-260

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

@@ -184,184 +251,251 @@

↥ Expand context

                 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",
                     ));
-194
+                }
                 ::std::write!(output, "/2015-03-31/functions/{FunctionName}/policy", FunctionName = function_name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-198
+            }
             fn uri_query(
                 _input: &crate::operation::get_policy::GetPolicyInput,
                 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.qualifier {
-205
+                    {
                         query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
-207
+                    }
-208
+                }
                 ::std::result::Result::Ok(())
-210
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_policy::GetPolicyInput,
                 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))
-220
+            }
             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("");
-225
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-227
+    }
-228
+}
 #[derive(Debug)]
 struct GetPolicyEndpointParamsInterceptor;
-231

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetPolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetPolicyEndpointParamsInterceptor"
-235
+    }
-236
     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::<GetPolicyInput>()
             .ok_or("failed to downcast to GetPolicyInput")?;
-251

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

@@ -207,207 +274,274 @@

↥ Expand context

-207
+                }
                 ::std::write!(
                     output,
                     "/2019-09-30/functions/{FunctionName}/provisioned-concurrency",
                     FunctionName = function_name
-212
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-215
+            }
             fn uri_query(
                 _input: &crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigInput,
                 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);
                 let inner_2 = &_input.qualifier;
                 let inner_2 = inner_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("qualifier", "cannot be empty or unset"))?;
                 if inner_2.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "qualifier",
                         "cannot be empty or unset",
                     ));
-230
+                }
                 query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
                 ::std::result::Result::Ok(())
-233
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_provisioned_concurrency_config::GetProvisionedConcurrencyConfigInput,
                 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))
-243
+            }
             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("");
-248
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-250
+    }
-251
+}
 #[derive(Debug)]
 struct GetProvisionedConcurrencyConfigEndpointParamsInterceptor;
-254

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetProvisionedConcurrencyConfigEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetProvisionedConcurrencyConfigEndpointParamsInterceptor"
-258
+    }
-259
     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::<GetProvisionedConcurrencyConfigInput>()
             .ok_or("failed to downcast to GetProvisionedConcurrencyConfigInput")?;
-274

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/get_runtime_management_config.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-07-20/functions/{FunctionName}/runtime-management-config",
                     FunctionName = function_name
-204
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-207
+            }
             fn uri_query(
                 _input: &crate::operation::get_runtime_management_config::GetRuntimeManagementConfigInput,
                 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.qualifier {
-214
+                    {
                         query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
-216
+                    }
-217
+                }
                 ::std::result::Result::Ok(())
-219
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_runtime_management_config::GetRuntimeManagementConfigInput,
                 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 GetRuntimeManagementConfigEndpointParamsInterceptor;
-240

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetRuntimeManagementConfigEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetRuntimeManagementConfigEndpointParamsInterceptor"
-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::<GetRuntimeManagementConfigInput>()
             .ok_or("failed to downcast to GetRuntimeManagementConfigInput")?;
-260

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

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

↥ Expand context

                 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",
                     ));
-186
+                }
                 ::std::write!(output, "/2015-03-31/functions/{FunctionName}/invocations", FunctionName = function_name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-190
+            }
             fn uri_query(
                 _input: &crate::operation::invoke::InvokeInput,
                 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.qualifier {
-197
+                    {
                         query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
-199
+                    }
-200
+                }
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::invoke::InvokeInput,
                 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)?;
                 let builder = crate::protocol_serde::shape_invoke::ser_invoke_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-213
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
             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/octet-stream");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_invoke_input::ser_payload_http_payload(input.payload)?);
         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 InvokeEndpointParamsInterceptor;
-228
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InvokeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "InvokeEndpointParamsInterceptor"

↧ 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::<InvokeInput>().ok_or("failed to downcast to InvokeInput")?;
-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))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .build()

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

@@ -173,173 +246,246 @@

↥ 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::invoke_async::InvokeAsyncInput,
                 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",
                     ));
-195
+                }
                 ::std::write!(output, "/2014-11-13/functions/{FunctionName}/invoke-async", FunctionName = function_name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-199
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::invoke_async::InvokeAsyncInput,
                 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))
-208
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
             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/octet-stream");
             builder
         };
         let body = crate::protocol_serde::shape_invoke_async_input::ser_invoke_args_http_payload(input.invoke_args)?.into_inner();
         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);
-217
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-219
+    }
-220
+}
 #[derive(Debug)]
 struct InvokeAsyncEndpointParamsInterceptor;
-223
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InvokeAsyncEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "InvokeAsyncEndpointParamsInterceptor"

↧ Expand context

-227
+    }
-228
     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::<InvokeAsyncInput>()
             .ok_or("failed to downcast to InvokeAsyncInput")?;
-243
         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/invoke_with_response_stream.rs

@@ -207,207 +284,284 @@

↥ 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",
                     ));
-213
+                }
                 ::std::write!(
                     output,
                     "/2021-11-15/functions/{FunctionName}/response-streaming-invocations",
                     FunctionName = function_name
-218
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-221
+            }
             fn uri_query(
                 _input: &crate::operation::invoke_with_response_stream::InvokeWithResponseStreamInput,
                 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.qualifier {
-228
+                    {
                         query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
-230
+                    }
-231
+                }
                 ::std::result::Result::Ok(())
-233
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::invoke_with_response_stream::InvokeWithResponseStreamInput,
                 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)?;
                 let builder = crate::protocol_serde::shape_invoke_with_response_stream::ser_invoke_with_response_stream_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-244
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
             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/octet-stream");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_invoke_with_response_stream_input::ser_payload_http_payload(
             input.payload,
         )?);
         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);
-255
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-257
+    }
-258
+}
 #[derive(Debug)]
 struct InvokeWithResponseStreamEndpointParamsInterceptor;
-261
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InvokeWithResponseStreamEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "InvokeWithResponseStreamEndpointParamsInterceptor"

↧ Expand context

-265
+    }
-266
     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::<InvokeWithResponseStreamInput>()
             .ok_or("failed to downcast to InvokeWithResponseStreamInput")?;
-281
         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: