AWS SDK

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

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

             .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::delete_function_concurrency::DeleteFunctionConcurrencyInput,
                 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::delete_function_concurrency::DeleteFunctionConcurrencyInput,
                 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("DELETE").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 DeleteFunctionConcurrencyEndpointParamsInterceptor;
-223

↧ Expand context

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

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

@@ -201,201 +268,268 @@

↥ 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",
                     ));
-207
+                }
                 ::std::write!(
                     output,
                     "/2019-09-25/functions/{FunctionName}/event-invoke-config",
                     FunctionName = function_name
-212
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-215
+            }
             fn uri_query(
                 _input: &crate::operation::delete_function_event_invoke_config::DeleteFunctionEventInvokeConfigInput,
                 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 {
-222
+                    {
                         query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
-224
+                    }
-225
+                }
                 ::std::result::Result::Ok(())
-227
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_function_event_invoke_config::DeleteFunctionEventInvokeConfigInput,
                 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("DELETE").uri(uri))
-237
+            }
             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("");
-242
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-244
+    }
-245
+}
 #[derive(Debug)]
 struct DeleteFunctionEventInvokeConfigEndpointParamsInterceptor;
-248

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/delete_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::delete_function_url_config::DeleteFunctionUrlConfigInput,
                 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::delete_function_url_config::DeleteFunctionUrlConfigInput,
                 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("DELETE").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 DeleteFunctionUrlConfigEndpointParamsInterceptor;
-235

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/delete_layer_version.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}",
                     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::delete_layer_version::DeleteLayerVersionInput,
                 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("DELETE").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 DeleteLayerVersionEndpointParamsInterceptor;
-240

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/delete_provisioned_concurrency_config.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::delete_provisioned_concurrency_config::DeleteProvisionedConcurrencyConfigInput,
                 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",
                     ));
-232
+                }
                 query.push_kv("Qualifier", &::aws_smithy_http::query::fmt_string(inner_2));
                 ::std::result::Result::Ok(())
-235
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_provisioned_concurrency_config::DeleteProvisionedConcurrencyConfigInput,
                 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("DELETE").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 DeleteProvisionedConcurrencyConfigEndpointParamsInterceptor;
-256

↧ Expand context

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

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

@@ -165,165 +231,231 @@

↥ Expand context

-165
+}
 #[derive(Debug)]
 struct GetAccountSettingsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetAccountSettingsRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::get_account_settings::GetAccountSettingsInput>()
             .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_account_settings::GetAccountSettingsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/2016-08-19/account-settings").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_account_settings::GetAccountSettingsInput,
                 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))
-200
+            }
             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("");
-205
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-207
+    }
-208
+}
 #[derive(Debug)]
 struct GetAccountSettingsEndpointParamsInterceptor;
-211

↧ Expand context

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

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

@@ -184,184 +250,250 @@

↥ 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",
                     ));
-190
+                }
                 let input_2 = &_input.name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "name",
                         "cannot be empty or unset",
                     ));
-201
+                }
                 ::std::write!(
                     output,

                     "/2015-03-31/functions/{FunctionName}/aliases/{Name}",
                     FunctionName = function_name,
                     Name = name
-207
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-210
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_alias::GetAliasInput,
                 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))
-219
+            }
             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("");
-224
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-226
+    }
-227
+}
 #[derive(Debug)]
 struct GetAliasEndpointParamsInterceptor;
-230

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/get_code_signing_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_code_signing_config::GetCodeSigningConfigInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.code_signing_config_arn;
                 let input_1 = input_1.as_ref().ok_or_else(|| {
                     ::aws_smithy_types::error::operation::BuildError::missing_field("code_signing_config_arn", "cannot be empty or unset")
                 })?;
                 let code_signing_config_arn = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if code_signing_config_arn.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "code_signing_config_arn",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(

                     output,
                     "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}",
                     CodeSigningConfigArn = code_signing_config_arn
-204
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-207
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_code_signing_config::GetCodeSigningConfigInput,
                 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 GetCodeSigningConfigEndpointParamsInterceptor;
-227

↧ Expand context

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

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

@@ -176,176 +242,242 @@

↥ Expand context

             .downcast::<crate::operation::get_event_source_mapping::GetEventSourceMappingInput>()
             .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_event_source_mapping::GetEventSourceMappingInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.uuid;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("uuid", "cannot be empty or unset"))?;
                 let uuid = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if uuid.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "uuid",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/2015-03-31/event-source-mappings/{UUID}", UUID = uuid).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_event_source_mapping::GetEventSourceMappingInput,
                 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))
-211
+            }
             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("");
-216
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-218
+    }
-219
+}
 #[derive(Debug)]
 struct GetEventSourceMappingEndpointParamsInterceptor;
-222

↧ Expand context

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

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

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

↥ 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",
                     ));
-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

AWS SDK

Files changed: