AWS SDK

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_hosted_zone_limit.rs

@@ -196,196 +262,262 @@

                 let hosted_zone_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if hosted_zone_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "hosted_zone_id",
                         "cannot be empty or unset",
                     ));
-202
+                }
                 let input_2 = &_input.r#type;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("r#type", "cannot be empty or unset"))?;
                 let r#type = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if r#type.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "r#type",
                         "cannot be empty or unset",
                     ));
-213
+                }
                 ::std::write!(
                     output,

                     "/2013-04-01/hostedzonelimit/{HostedZoneId}/{Type}",
                     HostedZoneId = hosted_zone_id,
                     Type = r#type
-219
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-222
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_hosted_zone_limit::GetHostedZoneLimitInput,
                 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))
-231
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-236
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-238
+    }
-239
+}
 #[derive(Debug)]
 struct GetHostedZoneLimitEndpointParamsInterceptor;
-242

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_query_logging_config.rs

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

↥ Expand context

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

                         "id",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/2013-04-01/queryloggingconfig/{Id}", Id = id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_query_logging_config::GetQueryLoggingConfigInput,
                 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 GetQueryLoggingConfigEndpointParamsInterceptor;
-222

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_reusable_delegation_set.rs

@@ -179,179 +245,245 @@

↥ Expand context

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

                         "id",
                         "cannot be empty or unset",
                     ));
-202
+                }
                 ::std::write!(output, "/2013-04-01/delegationset/{Id}", Id = id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-205
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_reusable_delegation_set::GetReusableDelegationSetInput,
                 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))
-214
+            }
             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("");
-219
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-221
+    }
-222
+}
 #[derive(Debug)]
 struct GetReusableDelegationSetEndpointParamsInterceptor;
-225

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_reusable_delegation_set_limit.rs

@@ -202,202 +268,268 @@

↥ Expand context

                 let delegation_set_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if delegation_set_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "delegation_set_id",
                         "cannot be empty or unset",
                     ));
-208
+                }
                 let input_2 = &_input.r#type;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("r#type", "cannot be empty or unset"))?;
                 let r#type = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if r#type.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "r#type",
                         "cannot be empty or unset",
                     ));
-219
+                }
                 ::std::write!(
                     output,

                     "/2013-04-01/reusabledelegationsetlimit/{DelegationSetId}/{Type}",
                     DelegationSetId = delegation_set_id,
                     Type = r#type
-225
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-228
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_reusable_delegation_set_limit::GetReusableDelegationSetLimitInput,
                 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))
-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 GetReusableDelegationSetLimitEndpointParamsInterceptor;
-248

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_traffic_policy.rs

@@ -188,188 +254,254 @@

↥ Expand context

                 use ::std::fmt::Write as _;
                 let input_1 = &_input.id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
                 let id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "id",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 let input_2 = &_input.version;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("version", "cannot be empty or unset"))?;
                 let mut version_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_2);
                 let version = version_encoder.encode();
                 if version.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "version",
                         "cannot be empty or unset",
                     ));
-211
+                }
                 ::std::write!(output, "/2013-04-01/trafficpolicy/{Id}/{Version}", Id = id, Version = version).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-214
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_traffic_policy::GetTrafficPolicyInput,
                 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))
-223
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-228
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-230
+    }
-231
+}
 #[derive(Debug)]
 struct GetTrafficPolicyEndpointParamsInterceptor;
-234

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_traffic_policy_instance.rs

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

↥ Expand context

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

                         "id",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/2013-04-01/trafficpolicyinstance/{Id}", Id = id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_traffic_policy_instance::GetTrafficPolicyInstanceInput,
                 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 GetTrafficPolicyInstanceEndpointParamsInterceptor;
-222

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_traffic_policy_instance_count.rs

@@ -171,171 +237,237 @@

↥ Expand context

-171
+}
 #[derive(Debug)]
 struct GetTrafficPolicyInstanceCountRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetTrafficPolicyInstanceCountRequestSerializer {
     #[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_traffic_policy_instance_count::GetTrafficPolicyInstanceCountInput>()
             .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_traffic_policy_instance_count::GetTrafficPolicyInstanceCountInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/2013-04-01/trafficpolicyinstancecount").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-197
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_traffic_policy_instance_count::GetTrafficPolicyInstanceCountInput,
                 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))
-206
+            }
             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("");
-211
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-213
+    }
-214
+}
 #[derive(Debug)]
 struct GetTrafficPolicyInstanceCountEndpointParamsInterceptor;
-217

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_cidr_blocks.rs

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

↥ Expand context

                     CollectionId = collection_id
-204
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-207
+            }
             fn uri_query(
                 _input: &crate::operation::list_cidr_blocks::ListCidrBlocksInput,
                 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.location_name {
-214
+                    {
                         query.push_kv("location", &::aws_smithy_http::query::fmt_string(inner_2));
-216
+                    }
-217
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.next_token {
-219
+                    {
                         query.push_kv("nexttoken", &::aws_smithy_http::query::fmt_string(inner_3));
-221
+                    }
-222
+                }

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

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_cidr_collections.rs

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

↥ Expand context

         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_cidr_collections::ListCidrCollectionsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/2013-04-01/cidrcollection").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(
                 _input: &crate::operation::list_cidr_collections::ListCidrCollectionsInput,
                 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.next_token {
-198
+                    {
                         query.push_kv("nexttoken", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }

                 if let ::std::option::Option::Some(inner_2) = &_input.max_results {
-203
+                    {
                         query.push_kv("maxresults", ::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_cidr_collections::ListCidrCollectionsInput,
                 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 ListCidrCollectionsEndpointParamsInterceptor;
-229

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_cidr_locations.rs

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

↥ Expand context

                 let collection_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if collection_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "collection_id",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/2013-04-01/cidrcollection/{CollectionId}", CollectionId = collection_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             fn uri_query(
                 _input: &crate::operation::list_cidr_locations::ListCidrLocationsInput,
                 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.next_token {
-209
+                    {
                         query.push_kv("nexttoken", &::aws_smithy_http::query::fmt_string(inner_2));
-211
+                    }
-212
+                }

                 if let ::std::option::Option::Some(inner_3) = &_input.max_results {
-214
+                    {
                         query.push_kv("maxresults", ::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_cidr_locations::ListCidrLocationsInput,
                 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 ListCidrLocationsEndpointParamsInterceptor;
-240

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_geo_locations.rs

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

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_geo_locations::ListGeoLocationsInput,
                 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.start_continent_code {
-198
+                    {
                         query.push_kv("startcontinentcode", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.start_country_code {
-203
+                    {
                         query.push_kv("startcountrycode", &::aws_smithy_http::query::fmt_string(inner_2));
-205
+                    }
-206
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.start_subdivision_code {
-208
+                    {
                         query.push_kv("startsubdivisioncode", &::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_geo_locations::ListGeoLocationsInput,
                 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 ListGeoLocationsEndpointParamsInterceptor;
-239

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_health_checks.rs

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

↥ Expand context

         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_health_checks::ListHealthChecksInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/2013-04-01/healthcheck").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(
                 _input: &crate::operation::list_health_checks::ListHealthChecksInput,
                 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_health_checks::ListHealthChecksInput,
                 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 ListHealthChecksEndpointParamsInterceptor;
-229

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_hosted_zones.rs

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

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_hosted_zones::ListHostedZonesInput,
                 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
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.delegation_set_id {
-208
+                    {
                         query.push_kv("delegationsetid", &::aws_smithy_http::query::fmt_string(inner_3));
-210
+                    }
-211
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.hosted_zone_type {
-213
+                    {
                         query.push_kv("hostedzonetype", &::aws_smithy_http::query::fmt_string(inner_4));
-215
+                    }
-216
+                }
                 ::std::result::Result::Ok(())
-218
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_hosted_zones::ListHostedZonesInput,
                 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 ListHostedZonesEndpointParamsInterceptor;
-239

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_hosted_zones_by_name.rs

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

↥ Expand context

             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/2013-04-01/hostedzonesbyname").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(
                 _input: &crate::operation::list_hosted_zones_by_name::ListHostedZonesByNameInput,
                 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.dns_name {
-198
+                    {
                         query.push_kv("dnsname", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.hosted_zone_id {
-203
+                    {
                         query.push_kv("hostedzoneid", &::aws_smithy_http::query::fmt_string(inner_2));
-205
+                    }
-206
+                }

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

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_hosted_zones_by_vpc.rs

@@ -198,198 +265,265 @@

↥ Expand context

                 let inner_1 = inner_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vpc_id", "cannot be empty or unset"))?;
                 if inner_1.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vpc_id",
                         "cannot be empty or unset",
                     ));
-206
+                }
                 query.push_kv("vpcid", &::aws_smithy_http::query::fmt_string(inner_1));
                 let inner_2 = &_input.vpc_region;
                 let inner_2 = inner_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vpc_region", "cannot be empty or unset"))?;
                 query.push_kv("vpcregion", &::aws_smithy_http::query::fmt_string(inner_2));
                 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
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.next_token {
-219
+                    {
                         query.push_kv("nexttoken", &::aws_smithy_http::query::fmt_string(inner_4));
-221
+                    }
-222
+                }
                 ::std::result::Result::Ok(())
-224
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_hosted_zones_by_vpc::ListHostedZonesByVpcInput,
                 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))
-234
+            }
             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("");
-239
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-241
+    }
-242
+}
 #[derive(Debug)]
 struct ListHostedZonesByVPCEndpointParamsInterceptor;
-245

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_query_logging_configs.rs

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

↥ Expand context

             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/2013-04-01/queryloggingconfig").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(
                 _input: &crate::operation::list_query_logging_configs::ListQueryLoggingConfigsInput,
                 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.hosted_zone_id {
-198
+                    {
                         query.push_kv("hostedzoneid", &::aws_smithy_http::query::fmt_string(inner_1));
-200
+                    }
-201
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.next_token {
-203
+                    {
                         query.push_kv("nexttoken", &::aws_smithy_http::query::fmt_string(inner_2));
-205
+                    }
-206
+                }

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

↧ Expand context

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

AWS SDK

Files changed: