AWS SDK

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

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

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

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

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

↥ Expand context

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

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

↧ Expand context

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

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

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

↥ Expand context

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

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

↧ Expand context

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

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

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

↥ Expand context

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

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

↧ Expand context

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

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

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

↥ Expand context

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

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

↧ Expand context

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

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

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

↥ Expand context

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

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

↧ Expand context

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

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

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

↥ Expand context

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

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

↧ Expand context

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

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

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

↥ Expand context

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

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

↧ Expand context

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

AWS SDK

Files changed: