AWS SDK

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

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

                 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

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

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

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_resource_record_sets::ListResourceRecordSetsInput,
                 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.start_record_name {
-213
+                    {
                         query.push_kv("name", &::aws_smithy_http::query::fmt_string(inner_2));
-215
+                    }
-216
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.start_record_type {
-218
+                    {
                         query.push_kv("type", &::aws_smithy_http::query::fmt_string(inner_3));
-220
+                    }
-221
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.start_record_identifier {
-223
+                    {
                         query.push_kv("identifier", &::aws_smithy_http::query::fmt_string(inner_4));
-225
+                    }
-226
+                }

                 if let ::std::option::Option::Some(inner_5) = &_input.max_items {
-228
+                    {
                         query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_5).encode());
-230
+                    }
-231
+                }
                 ::std::result::Result::Ok(())
-233
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_resource_record_sets::ListResourceRecordSetsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-243
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-248
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-250
+    }
-251
+}
 #[derive(Debug)]
 struct ListResourceRecordSetsEndpointParamsInterceptor;
-254

↧ Expand context

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

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

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

↥ Expand context

         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_reusable_delegation_sets::ListReusableDelegationSetsInput,
                 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/delegationset").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-197
+            }
             fn uri_query(
                 _input: &crate::operation::list_reusable_delegation_sets::ListReusableDelegationSetsInput,
                 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 {
-204
+                    {
                         query.push_kv("marker", &::aws_smithy_http::query::fmt_string(inner_1));
-206
+                    }
-207
+                }

                 if let ::std::option::Option::Some(inner_2) = &_input.max_items {
-209
+                    {
                         query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
-211
+                    }
-212
+                }
                 ::std::result::Result::Ok(())
-214
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_reusable_delegation_sets::ListReusableDelegationSetsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-224
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-229
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-231
+    }
-232
+}
 #[derive(Debug)]
 struct ListReusableDelegationSetsEndpointParamsInterceptor;
-235

↧ Expand context

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

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

@@ -193,193 +259,259 @@

↥ Expand context

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

                     "/2013-04-01/tags/{ResourceType}/{ResourceId}",
                     ResourceType = resource_type,
                     ResourceId = resource_id
-216
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-219
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_tags_for_resource::ListTagsForResourceInput,
                 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))
-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 ListTagsForResourceEndpointParamsInterceptor;
-239

↧ Expand context

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

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

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

↥ Expand context

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

                         "resource_type",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 ::std::write!(output, "/2013-04-01/tags/{ResourceType}", ResourceType = resource_type).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_tags_for_resources::ListTagsForResourcesInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-211
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_list_tags_for_resources::ser_list_tags_for_resources_op_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-222
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-224
+    }
-225
+}
 #[derive(Debug)]
 struct ListTagsForResourcesEndpointParamsInterceptor;
-228
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTagsForResourcesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListTagsForResourcesEndpointParamsInterceptor"

↧ Expand context

-232
+    }
-233
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListTagsForResourcesInput>()
             .ok_or("failed to downcast to ListTagsForResourcesInput")?;
-248
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))

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

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

↥ Expand context

         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_traffic_policies::ListTrafficPoliciesInput,
                 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/trafficpolicies").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-191
+            }
             fn uri_query(
                 _input: &crate::operation::list_traffic_policies::ListTrafficPoliciesInput,
                 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.traffic_policy_id_marker {
-198
+                    {
                         query.push_kv("trafficpolicyid", &::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_traffic_policies::ListTrafficPoliciesInput,
                 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 ListTrafficPoliciesEndpointParamsInterceptor;
-229

↧ Expand context

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

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

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

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesInput,
                 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_marker {
-204
+                    {
                         query.push_kv("hostedzoneid", &::aws_smithy_http::query::fmt_string(inner_1));
-206
+                    }
-207
+                }
                 if let ::std::option::Option::Some(inner_2) = &_input.traffic_policy_instance_name_marker {
-209
+                    {
                         query.push_kv("trafficpolicyinstancename", &::aws_smithy_http::query::fmt_string(inner_2));
-211
+                    }
-212
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.traffic_policy_instance_type_marker {
-214
+                    {
                         query.push_kv("trafficpolicyinstancetype", &::aws_smithy_http::query::fmt_string(inner_3));
-216
+                    }
-217
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.max_items {
-219
+                    {
                         query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-221
+                    }
-222
+                }
                 ::std::result::Result::Ok(())
-224
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_traffic_policy_instances::ListTrafficPolicyInstancesInput,
                 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 ListTrafficPolicyInstancesEndpointParamsInterceptor;
-245

↧ Expand context

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

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

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

↥ Expand context

                 let inner_1 = inner_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("hosted_zone_id", "cannot be empty or unset"))?;
                 if inner_1.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "hosted_zone_id",
                         "cannot be empty or unset",
                     ));
-216
+                }
                 query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
                 if let ::std::option::Option::Some(inner_2) = &_input.traffic_policy_instance_name_marker {
-219
+                    {
                         query.push_kv("trafficpolicyinstancename", &::aws_smithy_http::query::fmt_string(inner_2));
-221
+                    }
-222
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.traffic_policy_instance_type_marker {
-224
+                    {
                         query.push_kv("trafficpolicyinstancetype", &::aws_smithy_http::query::fmt_string(inner_3));
-226
+                    }
-227
+                }

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

↧ Expand context

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

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

@@ -218,218 +285,285 @@

↥ Expand context

                 let inner_2 = &_input.traffic_policy_version;
                 let inner_2 = inner_2.as_ref().ok_or_else(|| {
                     ::aws_smithy_types::error::operation::BuildError::missing_field("traffic_policy_version", "cannot be empty or unset")
                 })?;
                 query.push_kv("version", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
                 if let ::std::option::Option::Some(inner_3) = &_input.hosted_zone_id_marker {
-224
+                    {
                         query.push_kv("hostedzoneid", &::aws_smithy_http::query::fmt_string(inner_3));
-226
+                    }
-227
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.traffic_policy_instance_name_marker {
-229
+                    {
                         query.push_kv("trafficpolicyinstancename", &::aws_smithy_http::query::fmt_string(inner_4));
-231
+                    }
-232
+                }
                 if let ::std::option::Option::Some(inner_5) = &_input.traffic_policy_instance_type_marker {
-234
+                    {
                         query.push_kv("trafficpolicyinstancetype", &::aws_smithy_http::query::fmt_string(inner_5));
-236
+                    }
-237
+                }

                 if let ::std::option::Option::Some(inner_6) = &_input.max_items {
-239
+                    {
                         query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_6).encode());
-241
+                    }
-242
+                }
                 ::std::result::Result::Ok(())
-244
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyInput,
                 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))
-254
+            }
             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("");
-259
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-261
+    }
-262
+}
 #[derive(Debug)]
 struct ListTrafficPolicyInstancesByPolicyEndpointParamsInterceptor;
-265

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTrafficPolicyInstancesByPolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListTrafficPolicyInstancesByPolicyEndpointParamsInterceptor"
-269
+    }
-270
     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::<ListTrafficPolicyInstancesByPolicyInput>()
             .ok_or("failed to downcast to ListTrafficPolicyInstancesByPolicyInput")?;
-285

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

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

↥ Expand context

                 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",
                     ));
-205
+                }
                 ::std::write!(output, "/2013-04-01/trafficpolicies/{Id}/versions", Id = id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-208
+            }
             fn uri_query(
                 _input: &crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsInput,
                 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.traffic_policy_version_marker {
-215
+                    {
                         query.push_kv("trafficpolicyversion", &::aws_smithy_http::query::fmt_string(inner_2));
-217
+                    }
-218
+                }

                 if let ::std::option::Option::Some(inner_3) = &_input.max_items {
-220
+                    {
                         query.push_kv("maxitems", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-222
+                    }
-223
+                }
                 ::std::result::Result::Ok(())
-225
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-235
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-240
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-242
+    }
-243
+}
 #[derive(Debug)]
 struct ListTrafficPolicyVersionsEndpointParamsInterceptor;
-246

↧ Expand context

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

AWS SDK

Files changed: