AWS SDK

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

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

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

                 if let ::std::option::Option::Some(inner_3) = &_input.subdivision_code {
-208
+                    {
                         query.push_kv("subdivisioncode", &::aws_smithy_http::query::fmt_string(inner_3));
-210
+                    }
-211
+                }
                 ::std::result::Result::Ok(())
-213
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_geo_location::GetGeoLocationInput,
                 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 GetGeoLocationEndpointParamsInterceptor;
-234

↧ Expand context

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

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

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

↥ Expand context

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

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

↧ Expand context

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

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

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

↥ Expand context

-165
+}
 #[derive(Debug)]
 struct GetHealthCheckCountRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetHealthCheckCountRequestSerializer {
     #[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_health_check_count::GetHealthCheckCountInput>()
             .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_health_check_count::GetHealthCheckCountInput,
                 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/healthcheckcount").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_health_check_count::GetHealthCheckCountInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-200
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-205
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-207
+    }
-208
+}
 #[derive(Debug)]
 struct GetHealthCheckCountEndpointParamsInterceptor;
-211

↧ Expand context

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

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

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

↥ Expand context

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

                     output,
                     "/2013-04-01/healthcheck/{HealthCheckId}/lastfailurereason",
                     HealthCheckId = health_check_id
-214
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-217
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_health_check_last_failure_reason::GetHealthCheckLastFailureReasonInput,
                 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 GetHealthCheckLastFailureReasonEndpointParamsInterceptor;
-237

↧ Expand context

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

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

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

↥ Expand context

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

                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/2013-04-01/healthcheck/{HealthCheckId}/status", HealthCheckId = health_check_id)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-203
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_health_check_status::GetHealthCheckStatusInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-212
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-217
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-219
+    }
-220
+}
 #[derive(Debug)]
 struct GetHealthCheckStatusEndpointParamsInterceptor;
-223

↧ Expand context

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

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

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

↥ Expand context

             .downcast::<crate::operation::get_hosted_zone::GetHostedZoneInput>()
             .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_hosted_zone::GetHostedZoneInput,
                 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/hostedzone/{Id}", Id = id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_hosted_zone::GetHostedZoneInput,
                 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 GetHostedZoneEndpointParamsInterceptor;
-222

↧ Expand context

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

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

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

↥ Expand context

-165
+}
 #[derive(Debug)]
 struct GetHostedZoneCountRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetHostedZoneCountRequestSerializer {
     #[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_hosted_zone_count::GetHostedZoneCountInput>()
             .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_hosted_zone_count::GetHostedZoneCountInput,
                 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/hostedzonecount").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_hosted_zone_count::GetHostedZoneCountInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-200
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-205
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-207
+    }
-208
+}
 #[derive(Debug)]
 struct GetHostedZoneCountEndpointParamsInterceptor;
-211

↧ Expand context

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

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

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

↥ Expand context

                 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

AWS SDK

Files changed: