AWS SDK

tmp-codegen-diff/aws-sdk/sdk/s3/src/config/endpoint.rs

@@ -134,134 +204,198 @@

             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name` [Invalid access point ARN: access point name is invalid]");
         assert_eq!(
             format!("{}", error),
             "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name`"
-142
+        )
-143
+    }
-144
     /// Access points (disable access points explicitly false)
     #[test]
     fn test_7() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .disable_access_points(false)

             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-169
+                )
                 .build()
         );
-172
+    }
-173
     /// Access points: partition does not support FIPS
     #[test]
     fn test_8() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-1".to_string())

↧ Expand context

             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [Access points: partition does not support FIPS]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-189
+    }
-190
     /// Bucket region is invalid
     #[test]
     fn test_9() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)

@@ -265,259 +405,381 @@

↥ Expand context

             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err(
             "expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + access point + Dualstack is an error]",
         );
         assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
-267
+    }
-268
     /// Access point ARN with FIPS & Dualstack
     #[test]
     fn test_13() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_access_points(false)
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())

             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-294
+                )
                 .build()
         );
-297
+    }
-298
     /// Access point ARN with Dualstack
     #[test]
     fn test_14() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_access_points(false)
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-323
+                )
                 .build()
         );
-326
+    }
-327
     /// vanilla MRAP
     #[test]
     fn test_15() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
             .region("us-east-1".to_string())
             .disable_multi_region_access_points(false)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4a".to_string().into());
                         out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-352
+                )
                 .build()
         );
-355
+    }
-356
     /// MRAP does not support FIPS
     #[test]
     fn test_16() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())

↧ Expand context

             .region("us-east-1".to_string())
             .disable_multi_region_access_points(false)
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: S3 MRAP does not support FIPS [MRAP does not support FIPS]");
         assert_eq!(format!("{}", error), "S3 MRAP does not support FIPS")
-373
+    }
-374
     /// MRAP does not support DualStack
     #[test]
     fn test_17() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
             .region("us-east-1".to_string())
             .disable_multi_region_access_points(false)

@@ -446,422 +516,486 @@

↥ Expand context

             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: Invalid configuration: Multi-Region Access Point ARNs are disabled. [MRAP explicitly disabled]");
         assert_eq!(
             format!("{}", error),
             "Invalid configuration: Multi-Region Access Point ARNs are disabled."
-430
+        )
-431
+    }
-432
     /// Dual-stack endpoint with path-style forced
     #[test]
     fn test_20() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("bucketname".to_string())
             .region("us-west-2".to_string())
             .force_path_style(true)
             .use_fips(false)
             .accelerate(false)

             .use_dual_stack(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucketname");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-west-2.amazonaws.com/bucketname")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-457
+                )
                 .build()
         );
-460
+    }
-461
     /// Dual-stack endpoint + SDK::Host is error
     #[test]
     fn test_21() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("bucketname".to_string())

↧ Expand context

             .region("us-west-2".to_string())
             .force_path_style(true)
             .use_fips(false)
             .accelerate(false)
             .use_dual_stack(true)
             .endpoint("https://abc.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint
             .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [Dual-stack endpoint + SDK::Host is error]");
         assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
-480
+    }
-481
     /// path style + ARN bucket
     #[test]
     fn test_22() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)

@@ -518,488 +2508,2149 @@

↥ Expand context

             .force_path_style(true)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + ARN bucket]");
         assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
-498
+    }
-499
     /// implicit path style bucket + dualstack
     #[test]
     fn test_23() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99_ab".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(true)

             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/99_ab");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-west-2.amazonaws.com/99_ab")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-523
+                )
                 .build()
         );
-526
+    }
-527
     /// implicit path style bucket + dualstack
     #[test]
     fn test_24() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99_ab".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .endpoint("http://abc.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint
             .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [implicit path style bucket + dualstack]");
         assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
-545
+    }
-546
     /// don't allow URL injections in the bucket
     #[test]
     fn test_25() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("example.com#".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/example.com%23");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-west-2.amazonaws.com/example.com%23")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-570
+                )
                 .build()
         );
-573
+    }
-574
     /// URI encode bucket names in the path
     #[test]
     fn test_26() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("bucket name".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket%20name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-west-2.amazonaws.com/bucket%20name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-598
+                )
                 .build()
         );
-601
+    }
-602
     /// scheme is respected
     #[test]
     fn test_27() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99_ab".to_string())
             .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-627
+                )
                 .build()
         );
-630
+    }
-631
     /// scheme is respected (virtual addressing)
     #[test]
     fn test_28() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucketname".to_string())
             .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-656
+                )
                 .build()
         );
-659
+    }
-660
     /// path style + implicit private link
     #[test]
     fn test_29() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99_ab".to_string())
             .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-685
+                )
                 .build()
         );
-688
+    }
-689
     /// invalid Endpoint override
     #[test]
     fn test_30() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucketname".to_string())
             .endpoint("abcde://nota#url".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Custom endpoint `abcde://nota#url` was not a valid URI [invalid Endpoint override]");
         assert_eq!(format!("{}", error), "Custom endpoint `abcde://nota#url` was not a valid URI")
-706
+    }
-707
     /// using an IPv4 address forces path style
     #[test]
     fn test_31() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucketname".to_string())
             .endpoint("https://123.123.0.1".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://123.123.0.1/bucketname");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://123.123.0.1/bucketname")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-732
+                )
                 .build()
         );
-735
+    }
-736
     /// vanilla access point arn with region mismatch and UseArnRegion=false
     #[test]
     fn test_32() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:us-east-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .use_arn_region(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [vanilla access point arn with region mismatch and UseArnRegion=false]");
         assert_eq!(
             format!("{}", error),
             "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
-756
+        )
-757
+    }
-758
     /// vanilla access point arn with region mismatch and UseArnRegion unset
     #[test]
     fn test_33() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("us-east-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-783
+                )
                 .build()
         );
-786
+    }
-787
     /// vanilla access point arn with region mismatch and UseArnRegion=true
     #[test]
     fn test_34() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .use_arn_region(true)
             .region("us-east-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-813
+                )
                 .build()
         );
-816
+    }
-817
     /// subdomains are not allowed in virtual buckets
     #[test]
     fn test_35() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("bucket.name".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/bucket.name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-east-1.amazonaws.com/bucket.name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-838
+                )
                 .build()
         );
-841
+    }
-842
     /// bucket names with 3 characters are allowed in virtual buckets
     #[test]
     fn test_36() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("aaa".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://aaa.s3.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://aaa.s3.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-863
+                )
                 .build()
         );
-866
+    }
-867
     /// bucket names with fewer than 3 characters are not allowed in virtual host
     #[test]
     fn test_37() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("aa".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/aa");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-east-1.amazonaws.com/aa")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-888
+                )
                 .build()
         );
-891
+    }
-892
     /// bucket names with uppercase characters are not allowed in virtual host
     #[test]
     fn test_38() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("BucketName".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/BucketName");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-east-1.amazonaws.com/BucketName")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-913
+                )
                 .build()
         );
-916
+    }
-917
     /// subdomains are allowed in virtual buckets on http endpoints
     #[test]
     fn test_39() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("bucket.name".to_string())
             .region("us-east-1".to_string())
             .endpoint("http://example.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.name.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://bucket.name.example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-939
+                )
                 .build()
         );
-942
+    }
-943
     /// no region set
     #[test]
     fn test_40() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("bucket-name".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: A region must be set when sending requests to S3. [no region set]");
         assert_eq!(format!("{}", error), "A region must be set when sending requests to S3.")
-955
+    }
-956
     /// UseGlobalEndpoints=true, region=us-east-1 uses the global endpoint
     #[test]
     fn test_41() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-980
+                )
                 .build()
         );
-983
+    }
-984
     /// UseGlobalEndpoints=true, region=us-west-2 uses the regional endpoint
     #[test]
     fn test_42() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_global_endpoint(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-1008
+                )
                 .build()
         );
-1011
+    }
-1012
     /// UseGlobalEndpoints=true, region=cn-north-1 uses the regional endpoint
     #[test]
     fn test_43() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-1".to_string())
             .use_global_endpoint(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.cn-north-1.amazonaws.com.cn")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-1036
+                )
                 .build()
         );
-1039
+    }
-1040
     /// UseGlobalEndpoints=true, region=us-east-1, fips=true uses the regional endpoint with fips
     #[test]
     fn test_44() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1064
+                )
                 .build()
         );
-1067
+    }
-1068
     /// UseGlobalEndpoints=true, region=us-east-1, dualstack=true uses the regional endpoint with dualstack
     #[test]
     fn test_45() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1092
+                )
                 .build()
         );
-1095
+    }
-1096
     /// UseGlobalEndpoints=true, region=us-east-1, dualstack and fips uses the regional endpoint with fips/dualstack
     #[test]
     fn test_46() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1120
+                )
                 .build()
         );
-1123
+    }
-1124
     /// UseGlobalEndpoints=true, region=us-east-1 with custom endpoint, uses custom
     #[test]
     fn test_47() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .endpoint("https://example.com".to_string())
             .use_global_endpoint(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1149
+                )
                 .build()
         );
-1152
+    }
-1153
     /// UseGlobalEndpoints=true, region=us-west-2 with custom endpoint, uses custom
     #[test]
     fn test_48() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .endpoint("https://example.com".to_string())
             .use_global_endpoint(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-1178
+                )
                 .build()
         );
-1181
+    }
-1182
     /// UseGlobalEndpoints=true, region=us-east-1 with accelerate on non bucket case uses the global endpoint and ignores accelerate
     #[test]
     fn test_49() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1206
+                )
                 .build()
         );
-1209
+    }
-1210
     /// aws-global region uses the global endpoint
     #[test]
     fn test_50() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1233
+                )
                 .build()
         );
-1236
+    }
-1237
     /// aws-global region with fips uses the regional endpoint
     #[test]
     fn test_51() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1260
+                )
                 .build()
         );
-1263
+    }
-1264
     /// aws-global region with dualstack uses the regional endpoint
     #[test]
     fn test_52() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1287
+                )
                 .build()
         );
-1290
+    }
-1291
     /// aws-global region with fips and dualstack uses the regional endpoint
     #[test]
     fn test_53() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1314
+                )
                 .build()
         );
-1317
+    }
-1318
     /// aws-global region with accelerate on non-bucket case, uses global endpoint and ignores accelerate
     #[test]
     fn test_54() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1341
+                )
                 .build()
         );
-1344
+    }
-1345
     /// aws-global region with custom endpoint, uses custom
     #[test]
     fn test_55() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .endpoint("https://example.com".to_string())
             .use_global_endpoint(false)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1370
+                )
                 .build()
         );
-1373
+    }
-1374
     /// virtual addressing, aws-global region uses the global endpoint
     #[test]
     fn test_56() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1398
+                )
                 .build()
         );
-1401
+    }
-1402
     /// virtual addressing, aws-global region with Prefix, and Key uses the global endpoint. Prefix and Key parameters should not be used in endpoint evaluation.
     #[test]
     fn test_57() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .prefix("prefix".to_string())
             .key("key".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1428
+                )
                 .build()
         );
-1431
+    }
-1432
     /// virtual addressing, aws-global region with Copy Source, and Key uses the global endpoint. Copy Source and Key parameters should not be used in endpoint evaluation.
     #[test]
     fn test_58() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .copy_source("/copy/source".to_string())
             .key("key".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1458
+                )
                 .build()
         );
-1461
+    }
-1462
     /// virtual addressing, aws-global region with fips uses the regional fips endpoint
     #[test]
     fn test_59() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1486
+                )
                 .build()
         );
-1489
+    }
-1490
     /// virtual addressing, aws-global region with dualstack uses the regional dualstack endpoint
     #[test]
     fn test_60() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1514
+                )
                 .build()
         );
-1517
+    }
-1518
     /// virtual addressing, aws-global region with fips/dualstack uses the regional fips/dualstack endpoint
     #[test]
     fn test_61() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1542
+                )
                 .build()
         );
-1545
+    }
-1546
     /// virtual addressing, aws-global region with accelerate uses the global accelerate endpoint
     #[test]
     fn test_62() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-accelerate.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1570
+                )
                 .build()
         );
-1573
+    }
-1574
     /// virtual addressing, aws-global region with custom endpoint
     #[test]
     fn test_63() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .endpoint("https://example.com".to_string())
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1599
+                )
                 .build()
         );
-1602
+    }
-1603
     /// virtual addressing, UseGlobalEndpoint and us-east-1 region uses the global endpoint
     #[test]
     fn test_64() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1628
+                )
                 .build()
         );
-1631
+    }
-1632
     /// virtual addressing, UseGlobalEndpoint and us-west-2 region uses the regional endpoint
     #[test]
     fn test_65() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_global_endpoint(true)
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-1657
+                )
                 .build()
         );
-1660
+    }
-1661
     /// virtual addressing, UseGlobalEndpoint and us-east-1 region and fips uses the regional fips endpoint
     #[test]
     fn test_66() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .bucket("bucket-name".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1686
+                )
                 .build()
         );
-1689
+    }
-1690
     /// virtual addressing, UseGlobalEndpoint and us-east-1 region and dualstack uses the regional dualstack endpoint
     #[test]
     fn test_67() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1715
+                )
                 .build()
         );
-1718
+    }
-1719
     /// virtual addressing, UseGlobalEndpoint and us-east-1 region and accelerate uses the global accelerate endpoint
     #[test]
     fn test_68() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-accelerate.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1744
+                )
                 .build()
         );
-1747
+    }
-1748
     /// virtual addressing, UseGlobalEndpoint and us-east-1 region with custom endpoint
     #[test]
     fn test_69() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .endpoint("https://example.com".to_string())
             .use_global_endpoint(true)
             .bucket("bucket-name".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1774
+                )
                 .build()
         );
-1777
+    }
-1778
     /// ForcePathStyle, aws-global region uses the global endpoint
     #[test]
     fn test_70() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1803
+                )
                 .build()
         );
-1806
+    }
-1807
     /// ForcePathStyle, aws-global region with fips is invalid
     #[test]
     fn test_71() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.us-east-1.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1832
+                )
                 .build()
         );
-1835
+    }
-1836
     /// ForcePathStyle, aws-global region with dualstack uses regional dualstack endpoint
     #[test]
     fn test_72() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1861
+                )
                 .build()
         );
-1864
+    }
-1865
     /// ForcePathStyle, aws-global region custom endpoint uses the custom endpoint
     #[test]
     fn test_73() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .endpoint("https://example.com".to_string())
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://example.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1891
+                )
                 .build()
         );
-1894
+    }
-1895
     /// ForcePathStyle, UseGlobalEndpoint us-east-1 region uses the global endpoint
     #[test]
     fn test_74() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket-name".to_string())
             .use_global_endpoint(true)
             .force_path_style(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1921
+                )
                 .build()
         );
-1924
+    }
-1925
     /// ForcePathStyle, UseGlobalEndpoint us-west-2 region uses the regional endpoint
     #[test]
     fn test_75() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("bucket-name".to_string())
             .use_global_endpoint(true)
             .force_path_style(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-west-2.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-1951
+                )
                 .build()
         );
-1954
+    }
-1955
     /// ForcePathStyle, UseGlobalEndpoint us-east-1 region, dualstack uses the regional dualstack endpoint
     #[test]
     fn test_76() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket-name".to_string())
             .use_global_endpoint(true)
             .force_path_style(true)
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1981
+                )
                 .build()
         );
-1984
+    }
-1985
     /// ForcePathStyle, UseGlobalEndpoint us-east-1 region custom endpoint uses the custom endpoint
     #[test]
     fn test_77() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket-name".to_string())
             .endpoint("https://example.com".to_string())
             .use_global_endpoint(true)
             .force_path_style(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://example.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2012
+                )
                 .build()
         );
-2015
+    }
-2016
     /// ARN with aws-global region and  UseArnRegion uses the regional endpoint
     #[test]
     fn test_78() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_arn_region(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2048
+                )
                 .build()
         );
-2051
+    }
-2052
     /// cross partition MRAP ARN is an error
     #[test]
     fn test_79() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws-cn:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
             .region("us-west-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but bucket referred to partition `aws-cn` [cross partition MRAP ARN is an error]");
         assert_eq!(
             format!("{}", error),
             "Client was configured for partition `aws` but bucket referred to partition `aws-cn`"
-2067
+        )
-2068
+    }
-2069
     /// Endpoint override, accesspoint with HTTP, port
     #[test]
     fn test_80() {
         let params = crate::config::endpoint::Params::builder()
             .endpoint("http://beta.example.com:1234".to_string())
             .region("us-west-2".to_string())
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://myendpoint-123456789012.beta.example.com:1234")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2091
+                )
                 .build()
         );
-2094
+    }
-2095
     /// Endpoint override, accesspoint with http, path, query, and port
     #[test]
     fn test_81() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .endpoint("http://beta.example.com:1234/path".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234/path");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://myendpoint-123456789012.beta.example.com:1234/path")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2120
+                )
                 .build()
         );
-2123
+    }
-2124
     /// non-bucket endpoint override with FIPS = error
     #[test]
     fn test_82() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())

↧ Expand context

             .endpoint("http://beta.example.com:1234/path".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [non-bucket endpoint override with FIPS = error]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-2140
+    }
-2141
     /// FIPS + dualstack + custom endpoint
     #[test]
     fn test_83() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .endpoint("http://beta.example.com:1234/path".to_string())
             .use_fips(true)
             .use_dual_stack(true)

@@ -2521,2162 +2906,2487 @@

↥ Expand context

         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .endpoint("http://beta.example.com:1234/path".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [dualstack + custom endpoint]");
         assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
-2173
+    }
-2174
     /// custom endpoint without FIPS/dualstack
     #[test]
     fn test_85() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .endpoint("http://beta.example.com:1234/path".to_string())
             .use_fips(false)

             .use_dual_stack(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://beta.example.com:1234/path");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://beta.example.com:1234/path")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2197
+                )
                 .build()
         );
-2200
+    }
-2201
     /// s3 object lambda with access points disabled
     #[test]
     fn test_86() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .disable_access_points(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: Access points are not supported for this operation [s3 object lambda with access points disabled]");
         assert_eq!(format!("{}", error), "Access points are not supported for this operation")
-2216
+    }
-2217
     /// non bucket + FIPS
     #[test]
     fn test_87() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2239
+                )
                 .build()
         );
-2242
+    }
-2243
     /// standard non bucket endpoint
     #[test]
     fn test_88() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2265
+                )
                 .build()
         );
-2268
+    }
-2269
     /// non bucket endpoint with FIPS + Dualstack
     #[test]
     fn test_89() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2291
+                )
                 .build()
         );
-2294
+    }
-2295
     /// non bucket endpoint with dualstack
     #[test]
     fn test_90() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2317
+                )
                 .build()
         );
-2320
+    }
-2321
     /// use global endpoint + IP address endpoint override
     #[test]
     fn test_91() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .endpoint("http://127.0.0.1".to_string())
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://127.0.0.1/bucket");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://127.0.0.1/bucket")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2346
+                )
                 .build()
         );
-2349
+    }
-2350
     /// non-dns endpoint + global endpoint
     #[test]
     fn test_92() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2374
+                )
                 .build()
         );
-2377
+    }
-2378
     /// endpoint override + use global endpoint
     #[test]
     fn test_93() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .use_global_endpoint(true)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://foo.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2403
+                )
                 .build()
         );
-2406
+    }
-2407
     /// FIPS + dualstack + non-bucket endpoint
     #[test]
     fn test_94() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2430
+                )
                 .build()
         );
-2433
+    }
-2434
     /// FIPS + dualstack + non-DNS endpoint
     #[test]
     fn test_95() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .force_path_style(true)
             .use_fips(true)
             .use_dual_stack(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2458
+                )
                 .build()
         );
-2461
+    }
-2462
     /// endpoint override + FIPS + dualstack (BUG)
     #[test]
     fn test_96() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())

↧ Expand context

             .bucket("bucket!".to_string())
             .force_path_style(true)
             .use_fips(true)
             .use_dual_stack(false)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + FIPS + dualstack (BUG)]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-2480
+    }
-2481
     /// endpoint override + non-dns bucket + FIPS (BUG)
     #[test]
     fn test_97() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())

@@ -2908,2489 +3263,2796 @@

↥ Expand context

             .use_dual_stack(false)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-dns bucket + FIPS (BUG)]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-2498
+    }
-2499
     /// FIPS + bucket endpoint + force path style
     #[test]
     fn test_98() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .force_path_style(true)
             .use_fips(true)
             .use_dual_stack(false)

             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2524
+                )
                 .build()
         );
-2527
+    }
-2528
     /// bucket + FIPS + force path style
     #[test]
     fn test_99() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket".to_string())
             .force_path_style(true)
             .use_fips(true)
             .use_dual_stack(true)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2553
+                )
                 .build()
         );
-2556
+    }
-2557
     /// FIPS + dualstack + use global endpoint
     #[test]
     fn test_100() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2581
+                )
                 .build()
         );
-2584
+    }
-2585
     /// URI encoded bucket + use global endpoint
     #[test]
     fn test_101() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .use_global_endpoint(true)
             .endpoint("https://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [URI encoded bucket + use global endpoint]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-2602
+    }
-2603
     /// FIPS + path based endpoint
     #[test]
     fn test_102() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2628
+                )
                 .build()
         );
-2631
+    }
-2632
     /// accelerate + dualstack + global endpoint
     #[test]
     fn test_103() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(true)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket.s3-accelerate.dualstack.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2657
+                )
                 .build()
         );
-2660
+    }
-2661
     /// dualstack + global endpoint + non URI safe bucket
     #[test]
     fn test_104() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .accelerate(false)
             .use_dual_stack(true)
             .use_fips(false)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2686
+                )
                 .build()
         );
-2689
+    }
-2690
     /// FIPS + uri encoded bucket
     #[test]
     fn test_105() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .force_path_style(true)
             .accelerate(false)
             .use_dual_stack(false)
             .use_fips(true)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2716
+                )
                 .build()
         );
-2719
+    }
-2720
     /// endpoint override + non-uri safe endpoint + force path style
     #[test]
     fn test_106() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .force_path_style(true)
             .accelerate(false)
             .use_dual_stack(false)
             .use_fips(true)
             .endpoint("http://foo.com".to_string())
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err(
             "expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-uri safe endpoint + force path style]",
         );
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-2741
+    }
-2742
     /// FIPS + Dualstack + global endpoint + non-dns bucket
     #[test]
     fn test_107() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("bucket!".to_string())
             .accelerate(false)
             .use_dual_stack(true)
             .use_fips(true)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2767
+                )
                 .build()
         );
-2770
+    }
-2771
     /// endpoint override + FIPS + dualstack
     #[test]
     fn test_108() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())

↧ Expand context

             .use_dual_stack(true)
             .use_fips(true)
             .use_global_endpoint(true)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint
             .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override + FIPS + dualstack]");
         assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
-2788
+    }
-2789
     /// non-bucket endpoint override + dualstack + global endpoint
     #[test]
     fn test_109() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(false)
             .use_dual_stack(true)

@@ -3296,2829 +3720,3199 @@

↥ Expand context

             .region("cn-north-1".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [non-FIPS partition with FIPS set + custom endpoint]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-2839
+    }
-2840
     /// aws-global signs as us-east-1
     #[test]
     fn test_112() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket!".to_string())
             .use_fips(true)
             .accelerate(false)

             .use_dual_stack(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2864
+                )
                 .build()
         );
-2867
+    }
-2868
     /// aws-global signs as us-east-1
     #[test]
     fn test_113() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .accelerate(false)
             .endpoint("https://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.foo.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket.foo.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2893
+                )
                 .build()
         );
-2896
+    }
-2897
     /// aws-global + dualstack + path-only bucket
     #[test]
     fn test_114() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket!".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2921
+                )
                 .build()
         );
-2924
+    }
-2925
     /// aws-global + path-only bucket
     #[test]
     fn test_115() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket!".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2946
+                )
                 .build()
         );
-2949
+    }
-2950
     /// aws-global + fips + custom endpoint
     #[test]
     fn test_116() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket!".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .accelerate(false)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + fips + custom endpoint]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-2967
+    }
-2968
     /// aws-global, endpoint override & path only-bucket
     #[test]
     fn test_117() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket!".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .accelerate(false)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://foo.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2993
+                )
                 .build()
         );
-2996
+    }
-2997
     /// aws-global + dualstack + custom endpoint
     #[test]
     fn test_118() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .accelerate(false)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint
             .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [aws-global + dualstack + custom endpoint]");
         assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
-3014
+    }
-3015
     /// accelerate, dualstack + aws-global
     #[test]
     fn test_119() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .accelerate(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3039
+                )
                 .build()
         );
-3042
+    }
-3043
     /// FIPS + aws-global + path only bucket. This is not supported by S3 but we allow garbage in garbage out
     #[test]
     fn test_120() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket!".to_string())
             .force_path_style(true)
             .use_dual_stack(true)
             .use_fips(true)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3068
+                )
                 .build()
         );
-3071
+    }
-3072
     /// aws-global + FIPS + endpoint override.
     #[test]
     fn test_121() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_fips(true)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + FIPS + endpoint override.]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-3086
+    }
-3087
     /// force path style, FIPS, aws-global & endpoint override
     #[test]
     fn test_122() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket!".to_string())
             .force_path_style(true)
             .use_fips(true)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint
             .expect_err("expected error: A custom endpoint cannot be combined with FIPS [force path style, FIPS, aws-global & endpoint override]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-3104
+    }
-3105
     /// ip address causes path style to be forced
     #[test]
     fn test_123() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket".to_string())
             .endpoint("http://192.168.1.1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.1.1/bucket");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://192.168.1.1/bucket")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3127
+                )
                 .build()
         );
-3130
+    }
-3131
     /// endpoint override with aws-global region
     #[test]
     fn test_124() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint
             .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override with aws-global region]");
         assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
-3147
+    }
-3148
     /// FIPS + path-only (TODO: consider making this an error)
     #[test]
     fn test_125() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .bucket("bucket!".to_string())
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3170
+                )
                 .build()
         );
-3173
+    }
-3174
     /// empty arn type
     #[test]
     fn test_126() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-2".to_string())

↧ Expand context

             .bucket("arn:aws:not-s3:us-west-2:123456789012::myendpoint".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid ARN: No ARN type specified [empty arn type]");
         assert_eq!(format!("{}", error), "Invalid ARN: No ARN type specified")
-3187
+    }
-3188
     /// path style can't be used with accelerate
     #[test]
     fn test_127() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-2".to_string())
             .bucket("bucket!".to_string())
             .accelerate(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);

@@ -3899,3378 +4942,4265 @@

↥ Expand context

     #[test]
     fn test_139() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-2".to_string())
             .bucket("arn:aws:s3-outposts:us-east-1:12345789012:outpost".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid ARN: The Outpost Id was not set [invalid outpost type]");
         assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
-3389
+    }
-3390
     /// use global endpoint virtual addressing
     #[test]
     fn test_140() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-2".to_string())
             .bucket("bucket".to_string())
             .endpoint("http://example.com".to_string())

             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://bucket.example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-3413
+                )
                 .build()
         );
-3416
+    }
-3417
     /// global endpoint + ip address
     #[test]
     fn test_141() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-2".to_string())
             .bucket("bucket".to_string())
             .endpoint("http://192.168.0.1".to_string())
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.0.1/bucket");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://192.168.0.1/bucket")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-3440
+                )
                 .build()
         );
-3443
+    }
-3444
     /// invalid outpost type
     #[test]
     fn test_142() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-2".to_string())
             .bucket("bucket!".to_string())
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-2.amazonaws.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-east-2.amazonaws.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-3466
+                )
                 .build()
         );
-3469
+    }
-3470
     /// invalid outpost type
     #[test]
     fn test_143() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-2".to_string())
             .bucket("bucket".to_string())
             .accelerate(true)
             .use_global_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket.s3-accelerate.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-3493
+                )
                 .build()
         );
-3496
+    }
-3497
     /// use global endpoint + custom endpoint
     #[test]
     fn test_144() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-2".to_string())
             .bucket("bucket!".to_string())
             .use_global_endpoint(true)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://foo.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-3520
+                )
                 .build()
         );
-3523
+    }
-3524
     /// use global endpoint, not us-east-1, force path style
     #[test]
     fn test_145() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-2".to_string())
             .bucket("bucket!".to_string())
             .use_global_endpoint(true)
             .force_path_style(true)
             .endpoint("http://foo.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://foo.com/bucket%21")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-3548
+                )
                 .build()
         );
-3551
+    }
-3552
     /// vanilla virtual addressing@us-west-2
     #[test]
     fn test_146() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-3577
+                )
                 .build()
         );
-3580
+    }
-3581
     /// virtual addressing + dualstack@us-west-2
     #[test]
     fn test_147() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-3606
+                )
                 .build()
         );
-3609
+    }
-3610
     /// accelerate + dualstack@us-west-2
     #[test]
     fn test_148() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-3635
+                )
                 .build()
         );
-3638
+    }
-3639
     /// accelerate (dualstack=false)@us-west-2
     #[test]
     fn test_149() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-accelerate.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-3664
+                )
                 .build()
         );
-3667
+    }
-3668
     /// virtual addressing + fips@us-west-2
     #[test]
     fn test_150() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-fips.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-3693
+                )
                 .build()
         );
-3696
+    }
-3697
     /// virtual addressing + dualstack + fips@us-west-2
     #[test]
     fn test_151() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(true)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-3722
+                )
                 .build()
         );
-3725
+    }
-3726
     /// accelerate + fips = error@us-west-2
     #[test]
     fn test_152() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@us-west-2]");
         assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
-3743
+    }
-3744
     /// vanilla virtual addressing@cn-north-1
     #[test]
     fn test_153() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.cn-north-1.amazonaws.com.cn")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-3769
+                )
                 .build()
         );
-3772
+    }
-3773
     /// virtual addressing + dualstack@cn-north-1
     #[test]
     fn test_154() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("cn-north-1".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-3798
+                )
                 .build()
         );
-3801
+    }
-3802
     /// accelerate (dualstack=false)@cn-north-1
     #[test]
     fn test_155() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: S3 Accelerate cannot be used in this region [accelerate (dualstack=false)@cn-north-1]");
         assert_eq!(format!("{}", error), "S3 Accelerate cannot be used in this region")
-3819
+    }
-3820
     /// virtual addressing + fips@cn-north-1
     #[test]
     fn test_156() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [virtual addressing + fips@cn-north-1]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-3837
+    }
-3838
     /// vanilla virtual addressing@af-south-1
     #[test]
     fn test_157() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.af-south-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-3863
+                )
                 .build()
         );
-3866
+    }
-3867
     /// virtual addressing + dualstack@af-south-1
     #[test]
     fn test_158() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3.dualstack.af-south-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-3892
+                )
                 .build()
         );
-3895
+    }
-3896
     /// accelerate + dualstack@af-south-1
     #[test]
     fn test_159() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-3921
+                )
                 .build()
         );
-3924
+    }
-3925
     /// accelerate (dualstack=false)@af-south-1
     #[test]
     fn test_160() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-accelerate.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-3950
+                )
                 .build()
         );
-3953
+    }
-3954
     /// virtual addressing + fips@af-south-1
     #[test]
     fn test_161() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-fips.af-south-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-3979
+                )
                 .build()
         );
-3982
+    }
-3983
     /// virtual addressing + dualstack + fips@af-south-1
     #[test]
     fn test_162() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(true)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-4008
+                )
                 .build()
         );
-4011
+    }
-4012
     /// accelerate + fips = error@af-south-1
     #[test]
     fn test_163() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@af-south-1]");
         assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
-4029
+    }
-4030
     /// vanilla path style@us-west-2
     #[test]
     fn test_164() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-west-2.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-4055
+                )
                 .build()
         );
-4058
+    }
-4059
     /// fips@us-gov-west-2, bucket is not S3-dns-compatible (subdomains)
     #[test]
     fn test_165() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket.with.dots".to_string())
             .region("us-gov-west-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-gov-west-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-gov-west-1".to_string())
-4083
+                )
                 .build()
         );
-4086
+    }
-4087
     /// path style + accelerate = error@us-west-2
     #[test]
     fn test_166() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint
             .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@us-west-2]");
         assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
-4105
+    }
-4106
     /// path style + dualstack@us-west-2
     #[test]
     fn test_167() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("us-west-2".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.us-west-2.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-4131
+                )
                 .build()
         );
-4134
+    }
-4135
     /// path style + arn is error@us-west-2
     #[test]
     fn test_168() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .force_path_style(true)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@us-west-2]");
         assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
-4153
+    }
-4154
     /// path style + invalid DNS name@us-west-2
     #[test]
     fn test_169() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99a_b".to_string())
             .force_path_style(true)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-west-2.amazonaws.com/99a_b")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-4179
+                )
                 .build()
         );
-4182
+    }
-4183
     /// no path style + invalid DNS name@us-west-2
     #[test]
     fn test_170() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99a_b".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.us-west-2.amazonaws.com/99a_b")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-4207
+                )
                 .build()
         );
-4210
+    }
-4211
     /// vanilla path style@cn-north-1
     #[test]
     fn test_171() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.cn-north-1.amazonaws.com.cn/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-4236
+                )
                 .build()
         );
-4239
+    }
-4240
     /// path style + fips@cn-north-1
     #[test]
     fn test_172() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)

↧ Expand context

             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [path style + fips@cn-north-1]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-4257
+    }
-4258
     /// path style + accelerate = error@cn-north-1
     #[test]
     fn test_173() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(true)

@@ -4944,4267 +5386,4649 @@

↥ Expand context

             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint
             .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@cn-north-1]");
         assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
-4276
+    }
-4277
     /// path style + dualstack@cn-north-1
     #[test]
     fn test_174() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("cn-north-1".to_string())
             .use_dual_stack(true)

             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-4302
+                )
                 .build()
         );
-4305
+    }
-4306
     /// path style + arn is error@cn-north-1
     #[test]
     fn test_175() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .force_path_style(true)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@cn-north-1]");
         assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
-4324
+    }
-4325
     /// path style + invalid DNS name@cn-north-1
     #[test]
     fn test_176() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99a_b".to_string())
             .force_path_style(true)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-4350
+                )
                 .build()
         );
-4353
+    }
-4354
     /// no path style + invalid DNS name@cn-north-1
     #[test]
     fn test_177() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99a_b".to_string())
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-4378
+                )
                 .build()
         );
-4381
+    }
-4382
     /// vanilla path style@af-south-1
     #[test]
     fn test_178() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.af-south-1.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-4407
+                )
                 .build()
         );
-4410
+    }
-4411
     /// path style + fips@af-south-1
     #[test]
     fn test_179() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.af-south-1.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-fips.af-south-1.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-4436
+                )
                 .build()
         );
-4439
+    }
-4440
     /// path style + accelerate = error@af-south-1
     #[test]
     fn test_180() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint
             .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@af-south-1]");
         assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
-4458
+    }
-4459
     /// path style + dualstack@af-south-1
     #[test]
     fn test_181() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .region("af-south-1".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.af-south-1.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.dualstack.af-south-1.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-4484
+                )
                 .build()
         );
-4487
+    }
-4488
     /// path style + arn is error@af-south-1
     #[test]
     fn test_182() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .force_path_style(true)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@af-south-1]");
         assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
-4506
+    }
-4507
     /// path style + invalid DNS name@af-south-1
     #[test]
     fn test_183() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99a_b".to_string())
             .force_path_style(true)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.af-south-1.amazonaws.com/99a_b")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-4532
+                )
                 .build()
         );
-4535
+    }
-4536
     /// no path style + invalid DNS name@af-south-1
     #[test]
     fn test_184() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("99a_b".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3.af-south-1.amazonaws.com/99a_b")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-4560
+                )
                 .build()
         );
-4563
+    }
-4564
     /// virtual addressing + private link@us-west-2
     #[test]
     fn test_185() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-4590
+                )
                 .build()
         );
-4593
+    }
-4594
     /// path style + private link@us-west-2
     #[test]
     fn test_186() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-4620
+                )
                 .build()
         );
-4623
+    }
-4624
     /// SDK::Host + FIPS@us-west-2
     #[test]
     fn test_187() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)

↧ Expand context

             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@us-west-2]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-4642
+    }
-4643
     /// SDK::Host + DualStack@us-west-2
     #[test]
     fn test_188() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())

@@ -5410,4673 +5552,4797 @@

↥ Expand context

             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@us-west-2]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
-4681
+    }
-4682
     /// SDK::Host + access point ARN@us-west-2
     #[test]
     fn test_190() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .endpoint("https://beta.example.com".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(false)

             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.beta.example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-4708
+                )
                 .build()
         );
-4711
+    }
-4712
     /// virtual addressing + private link@cn-north-1
     #[test]
     fn test_191() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-4738
+                )
                 .build()
         );
-4741
+    }
-4742
     /// path style + private link@cn-north-1
     #[test]
     fn test_192() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-4768
+                )
                 .build()
         );
-4771
+    }
-4772
     /// FIPS@cn-north-1
     #[test]
     fn test_193() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)

↧ Expand context

             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [FIPS@cn-north-1]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-4789
+    }
-4790
     /// SDK::Host + DualStack@cn-north-1
     #[test]
     fn test_194() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)

@@ -5576,4821 +5718,4945 @@

↥ Expand context

             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@cn-north-1]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
-4829
+    }
-4830
     /// SDK::Host + access point ARN@cn-north-1
     #[test]
     fn test_196() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .endpoint("https://beta.example.com".to_string())
             .region("cn-north-1".to_string())
             .use_dual_stack(false)

             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.beta.example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-4856
+                )
                 .build()
         );
-4859
+    }
-4860
     /// virtual addressing + private link@af-south-1
     #[test]
     fn test_197() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-4886
+                )
                 .build()
         );
-4889
+    }
-4890
     /// path style + private link@af-south-1
     #[test]
     fn test_198() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())
             .force_path_style(true)
             .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-4916
+                )
                 .build()
         );
-4919
+    }
-4920
     /// SDK::Host + FIPS@af-south-1
     #[test]
     fn test_199() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)

↧ Expand context

             .bucket("bucket-name".to_string())
             .force_path_style(false)
             .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@af-south-1]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
-4938
+    }
-4939
     /// SDK::Host + DualStack@af-south-1
     #[test]
     fn test_200() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("bucket-name".to_string())

@@ -5743,4970 +5973,5170 @@

↥ Expand context

             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@af-south-1]");
         assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
-4978
+    }
-4979
     /// SDK::Host + access point ARN@af-south-1
     #[test]
     fn test_202() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .endpoint("https://beta.example.com".to_string())
             .region("af-south-1".to_string())
             .use_dual_stack(false)

             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.beta.example.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-5005
+                )
                 .build()
         );
-5008
+    }
-5009
     /// vanilla access point arn@us-west-2
     #[test]
     fn test_203() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-5034
+                )
                 .build()
         );
-5037
+    }
-5038
     /// access point arn + FIPS@us-west-2
     #[test]
     fn test_204() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-5063
+                )
                 .build()
         );
-5066
+    }
-5067
     /// access point arn + accelerate = error@us-west-2
     #[test]
     fn test_205() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@us-west-2]");
         assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
-5085
+    }
-5086
     /// access point arn + FIPS + DualStack@us-west-2
     #[test]
     fn test_206() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(true)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-5112
+                )
                 .build()
         );
-5115
+    }
-5116
     /// vanilla access point arn@cn-north-1
     #[test]
     fn test_207() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-5141
+                )
                 .build()
         );
-5144
+    }
-5145
     /// access point arn + FIPS@cn-north-1
     #[test]
     fn test_208() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)

↧ Expand context

             .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("cn-north-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS@cn-north-1]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-5162
+    }
-5163
     /// access point arn + accelerate = error@cn-north-1
     #[test]
     fn test_209() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)

@@ -5993,5190 +6245,5402 @@

↥ Expand context

             .region("cn-north-1".to_string())
             .use_dual_stack(true)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS + DualStack@cn-north-1]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-5199
+    }
-5200
     /// vanilla access point arn@af-south-1
     #[test]
     fn test_211() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(false)

             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-5225
+                )
                 .build()
         );
-5228
+    }
-5229
     /// access point arn + FIPS@af-south-1
     #[test]
     fn test_212() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-5254
+                )
                 .build()
         );
-5257
+    }
-5258
     /// access point arn + accelerate = error@af-south-1
     #[test]
     fn test_213() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@af-south-1]");
         assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
-5276
+    }
-5277
     /// access point arn + FIPS + DualStack@af-south-1
     #[test]
     fn test_214() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
             .force_path_style(false)
             .region("af-south-1".to_string())
             .use_dual_stack(true)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-5303
+                )
                 .build()
         );
-5306
+    }
-5307
     /// S3 outposts vanilla test
     #[test]
     fn test_215() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-5338
+                )
                 .build()
         );
-5341
+    }
-5342
     /// S3 outposts custom endpoint
     #[test]
     fn test_216() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
             .endpoint("https://example.amazonaws.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.example.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://reports-123456789012.op-01234567890123456.example.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-5373
+                )
                 .build()
         );
-5376
+    }
-5377
     /// outposts arn with region mismatch and UseArnRegion=false
     #[test]
     fn test_217() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)

↧ Expand context

             .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .force_path_style(false)
             .use_arn_region(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [outposts arn with region mismatch and UseArnRegion=false]");
         assert_eq!(
             format!("{}", error),
             "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
-5397
+        )
-5398
+    }
-5399
     /// outposts arn with region mismatch, custom region and UseArnRegion=false
     #[test]
     fn test_218() {

@@ -6257,5414 +6451,5575 @@

↥ Expand context

         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [outposts arn with region mismatch, custom region and UseArnRegion=false]");
         assert_eq!(
             format!("{}", error),
             "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
-5420
+        )
-5421
+    }
-5422
     /// outposts arn with region mismatch and UseArnRegion=true
     #[test]
     fn test_219() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .force_path_style(false)
             .use_arn_region(true)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)

             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-5455
+                )
                 .build()
         );
-5458
+    }
-5459
     /// outposts arn with region mismatch and UseArnRegion unset
     #[test]
     fn test_220() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .force_path_style(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-5491
+                )
                 .build()
         );
-5494
+    }
-5495
     /// outposts arn with partition mismatch and UseArnRegion=true
     #[test]
     fn test_221() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .force_path_style(false)
             .use_arn_region(true)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but ARN (`arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint`) has `aws-cn` [outposts arn with partition mismatch and UseArnRegion=true]");
         assert_eq!(format!("{}", error), "Client was configured for partition `aws` but ARN (`arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint`) has `aws-cn`")
-5513
+    }
-5514
     /// ARN with UseGlobalEndpoint and use-east-1 region uses the regional endpoint
     #[test]
     fn test_222() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_global_endpoint(true)
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-5546
+                )
                 .build()
         );
-5549
+    }
-5550
     /// S3 outposts does not support dualstack
     #[test]
     fn test_223() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())

↧ Expand context

             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: S3 Outposts does not support Dual-stack [S3 outposts does not support dualstack]");
         assert_eq!(format!("{}", error), "S3 Outposts does not support Dual-stack")
-5566
+    }
-5567
     /// S3 outposts does not support fips
     #[test]
     fn test_224() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)

@@ -6485,5609 +6751,5839 @@

↥ Expand context

             .accelerate(false)
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:mybucket:object:foo".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: Invalid Arn: Outpost Access Point ARN contains sub resources [validates against subresource]");
         assert_eq!(format!("{}", error), "Invalid Arn: Outpost Access Point ARN contains sub resources")
-5618
+    }
-5619
     /// object lambda @us-east-1
     #[test]
     fn test_227() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(false)

             .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-5644
+                )
                 .build()
         );
-5647
+    }
-5648
     /// object lambda @us-west-2
     #[test]
     fn test_228() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(false)
             .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-5673
+                )
                 .build()
         );
-5676
+    }
-5677
     /// object lambda, colon resource deliminator @us-west-2
     #[test]
     fn test_229() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(false)
             .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-5702
+                )
                 .build()
         );
-5705
+    }
-5706
     /// object lambda @us-east-1, client region us-west-2, useArnRegion=true
     #[test]
     fn test_230() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(true)
             .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-5731
+                )
                 .build()
         );
-5734
+    }
-5735
     /// object lambda @us-east-1, client region s3-external-1, useArnRegion=true
     #[test]
     fn test_231() {
         let params = crate::config::endpoint::Params::builder()
             .region("s3-external-1".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(true)
             .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-5760
+                )
                 .build()
         );
-5763
+    }
-5764
     /// object lambda @us-east-1, client region s3-external-1, useArnRegion=false
     #[test]
     fn test_232() {
         let params = crate::config::endpoint::Params::builder()
             .region("s3-external-1".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(false)
             .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `s3-external-1` and UseArnRegion is `false` [object lambda @us-east-1, client region s3-external-1, useArnRegion=false]");
         assert_eq!(
             format!("{}", error),
             "Invalid configuration: region from ARN `us-east-1` does not match client region `s3-external-1` and UseArnRegion is `false`"
-5783
+        )
-5784
+    }
-5785
     /// object lambda @us-east-1, client region aws-global, useArnRegion=true
     #[test]
     fn test_233() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(true)
             .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-5810
+                )
                 .build()
         );
-5813
+    }
-5814
     /// object lambda @us-east-1, client region aws-global, useArnRegion=false
     #[test]
     fn test_234() {
         let params = crate::config::endpoint::Params::builder()
             .region("aws-global".to_string())

↧ Expand context

             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(false)
             .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `aws-global` and UseArnRegion is `false` [object lambda @us-east-1, client region aws-global, useArnRegion=false]");
         assert_eq!(
             format!("{}", error),
             "Invalid configuration: region from ARN `us-east-1` does not match client region `aws-global` and UseArnRegion is `false`"
-5833
+        )
-5834
+    }
-5835
     /// object lambda @cn-north-1, client region us-west-2 (cross partition), useArnRegion=true
     #[test]
     fn test_235() {
         let params = crate::config::endpoint::Params::builder()

@@ -6773,5861 +6878,5954 @@

↥ Expand context

             .accelerate(false)
             .use_arn_region(false)
             .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [object lambda with dualstack]");
         assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
-5870
+    }
-5871
     /// object lambda @us-gov-east-1
     #[test]
     fn test_237() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-gov-east-1".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(false)

             .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-gov-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-gov-east-1".to_string())
-5896
+                )
                 .build()
         );
-5899
+    }
-5900
     /// object lambda @us-gov-east-1, with fips
     #[test]
     fn test_238() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-gov-east-1".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(false)
             .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-gov-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-gov-east-1".to_string())
-5925
+                )
                 .build()
         );
-5928
+    }
-5929
     /// object lambda @cn-north-1, with fips
     #[test]
     fn test_239() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-1".to_string())

↧ Expand context

             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(false)
             .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [object lambda @cn-north-1, with fips]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-5946
+    }
-5947
     /// object lambda with accelerate
     #[test]
     fn test_240() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(false)

@@ -7064,6140 +7293,6339 @@

↥ Expand context

             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid ARN: The ARN may only contain a single resource component after `accesspoint`. [object lambda with invalid arn - access point name contains sub resources]");
         assert_eq!(
             format!("{}", error),
             "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
-6147
+        )
-6148
+    }
-6149
     /// object lambda with custom endpoint
     #[test]
     fn test_250() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_arn_region(false)
             .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())

             .endpoint("https://my-endpoint.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.my-endpoint.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybanner-123456789012.my-endpoint.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-6175
+                )
                 .build()
         );
-6178
+    }
-6179
     /// object lambda arn with region mismatch and UseArnRegion=false
     #[test]
     fn test_251() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
             .force_path_style(false)
             .use_arn_region(false)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [object lambda arn with region mismatch and UseArnRegion=false]");
         assert_eq!(
             format!("{}", error),
             "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
-6199
+        )
-6200
+    }
-6201
     /// WriteGetObjectResponse @ us-west-2
     #[test]
     fn test_252() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .use_object_lambda_endpoint(true)
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-object-lambda.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-6225
+                )
                 .build()
         );
-6228
+    }
-6229
     /// WriteGetObjectResponse with custom endpoint
     #[test]
     fn test_253() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .use_object_lambda_endpoint(true)
             .endpoint("https://my-endpoint.com".to_string())
             .region("us-west-2".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://my-endpoint.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-6254
+                )
                 .build()
         );
-6257
+    }
-6258
     /// WriteGetObjectResponse @ us-east-1
     #[test]
     fn test_254() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .use_object_lambda_endpoint(true)
             .region("us-east-1".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-object-lambda.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-6282
+                )
                 .build()
         );
-6285
+    }
-6286
     /// WriteGetObjectResponse with fips
     #[test]
     fn test_255() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .use_object_lambda_endpoint(true)
             .region("us-east-1".to_string())
             .use_dual_stack(false)
             .use_fips(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-object-lambda-fips.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-6310
+                )
                 .build()
         );
-6313
+    }
-6314
     /// WriteGetObjectResponse with dualstack
     #[test]
     fn test_256() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)

↧ Expand context

             .use_object_lambda_endpoint(true)
             .region("us-east-1".to_string())
             .use_dual_stack(true)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [WriteGetObjectResponse with dualstack]");
         assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
-6330
+    }
-6331
     /// WriteGetObjectResponse with accelerate
     #[test]
     fn test_257() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(true)
             .use_object_lambda_endpoint(true)
             .region("us-east-1".to_string())
             .use_dual_stack(false)

@@ -7326,6372 +7647,6631 @@

↥ Expand context

             .region("not a valid DNS name".to_string())
             .use_dual_stack(false)
             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [WriteGetObjectResponse with invalid partition]");
         assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
-6382
+    }
-6383
     /// WriteGetObjectResponse with an unknown partition
     #[test]
     fn test_260() {
         let params = crate::config::endpoint::Params::builder()
             .accelerate(false)
             .use_object_lambda_endpoint(true)
             .region("us-east.special".to_string())
             .use_dual_stack(false)

             .use_fips(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east.special.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-object-lambda.us-east.special.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out.insert("signingRegion".to_string(), "us-east.special".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-object-lambda".to_string())
                         .put("signingRegion", "us-east.special".to_string())
-6407
+                )
                 .build()
         );
-6410
+    }
-6411
     /// S3 Outposts bucketAlias Real Outpost Prod us-west-1
     #[test]
     fn test_261() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-1".to_string())
             .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.us-west-1.amazonaws.com");
         assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.us-west-1.amazonaws.com")
     .property("authSchemes", vec![ {
         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
         out.insert("name".to_string(), "sigv4a".to_string().into());
         out.insert("signingName".to_string(), "s3-outposts".to_string().into());
         out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
         out.insert("disableDoubleEncoding".to_string(), true.into());
         out
     }.into()
     , {
         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
         out.insert("name".to_string(), "sigv4".to_string().into());
         out.insert("signingName".to_string(), "s3-outposts".to_string().into());
         out.insert("signingRegion".to_string(), "us-west-1".to_string().into());
         out.insert("disableDoubleEncoding".to_string(), true.into());
         out
     }.into()])
     .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
     .put("disableDoubleEncoding", true)
     .put("signingName", "s3-outposts".to_string())
     .put("signingRegionSet", vec!["*".to_string().into()])
-+
+    )
     .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
     .put("disableDoubleEncoding", true)
     .put("signingName", "s3-outposts".to_string())
     .put("signingRegion", "us-west-1".to_string())
-+
+    )
     .build());
-6438
+    }
-6439
     /// S3 Outposts bucketAlias Real Outpost Prod ap-east-1
     #[test]
     fn test_262() {
         let params = crate::config::endpoint::Params::builder()
             .region("ap-east-1".to_string())
             .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com");
         assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com")
     .property("authSchemes", vec![ {
         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
         out.insert("name".to_string(), "sigv4a".to_string().into());
         out.insert("signingName".to_string(), "s3-outposts".to_string().into());
         out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
         out.insert("disableDoubleEncoding".to_string(), true.into());
         out
     }.into()
     , {
         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
         out.insert("name".to_string(), "sigv4".to_string().into());
         out.insert("signingName".to_string(), "s3-outposts".to_string().into());
         out.insert("signingRegion".to_string(), "ap-east-1".to_string().into());
         out.insert("disableDoubleEncoding".to_string(), true.into());
         out
     }.into()])
     .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
     .put("disableDoubleEncoding", true)
     .put("signingName", "s3-outposts".to_string())
     .put("signingRegionSet", vec!["*".to_string().into()])
-+
+    )
     .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
     .put("disableDoubleEncoding", true)
     .put("signingName", "s3-outposts".to_string())
     .put("signingRegion", "ap-east-1".to_string())
-+
+    )
     .build());
-6466
+    }
-6467
     /// S3 Outposts bucketAlias Ec2 Outpost Prod us-east-1
     #[test]
     fn test_263() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-6497
+                )
                 .build()
         );
-6500
+    }
-6501
     /// S3 Outposts bucketAlias Ec2 Outpost Prod me-south-1
     #[test]
     fn test_264() {
         let params = crate::config::endpoint::Params::builder()
             .region("me-south-1".to_string())
             .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "me-south-1".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "me-south-1".to_string())
-6531
+                )
                 .build()
         );
-6534
+    }
-6535
     /// S3 Outposts bucketAlias Real Outpost Beta
     #[test]
     fn test_265() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
             .endpoint("https://example.amazonaws.com".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-6566
+                )
                 .build()
         );
-6569
+    }
-6570
     /// S3 Outposts bucketAlias Ec2 Outpost Beta
     #[test]
     fn test_266() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3".to_string())
             .endpoint("https://example.amazonaws.com".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4a".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into(),
--
+                        {
                             let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                             out.insert("name".to_string(), "sigv4".to_string().into());
                             out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                             out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                             out.insert("disableDoubleEncoding".to_string(), true.into());
                             out
--
+                        }
                         .into()
--
+                    ]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegionSet", vec!["*".to_string().into()])
-+
+                )
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-6602
+                )
                 .build()
         );
-6605
+    }
-6606
     /// S3 Outposts bucketAlias - No endpoint set for beta
     #[test]
     fn test_267() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())

↧ Expand context

             .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err(
             "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
         );
         assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
-6624
+    }
-6625
     /// S3 Outposts bucketAlias Invalid hardware type
     #[test]
     fn test_268() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("test-accessp-h0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())

@@ -7692,6676 +9997,8621 @@

↥ Expand context

             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err(
             "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
         );
         assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
-6685
+    }
-6686
     /// S3 Snow with bucket
     #[test]
     fn test_271() {
         let params = crate::config::endpoint::Params::builder()
             .region("snow".to_string())
             .bucket("bucketName".to_string())
             .endpoint("http://10.0.1.12:433".to_string())
             .use_fips(false)
             .use_dual_stack(false)

             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12:433/bucketName");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://10.0.1.12:433/bucketName")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "snow".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "snow".to_string())
-6711
+                )
                 .build()
         );
-6714
+    }
-6715
     /// S3 Snow without bucket
     #[test]
     fn test_272() {
         let params = crate::config::endpoint::Params::builder()
             .region("snow".to_string())
             .endpoint("https://10.0.1.12:433".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.1.12:433");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://10.0.1.12:433")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "snow".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "snow".to_string())
-6739
+                )
                 .build()
         );
-6742
+    }
-6743
     /// S3 Snow no port
     #[test]
     fn test_273() {
         let params = crate::config::endpoint::Params::builder()
             .region("snow".to_string())
             .bucket("bucketName".to_string())
             .endpoint("http://10.0.1.12".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12/bucketName");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://10.0.1.12/bucketName")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "snow".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "snow".to_string())
-6768
+                )
                 .build()
         );
-6771
+    }
-6772
     /// S3 Snow dns endpoint
     #[test]
     fn test_274() {
         let params = crate::config::endpoint::Params::builder()
             .region("snow".to_string())
             .bucket("bucketName".to_string())
             .endpoint("https://amazonaws.com".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://amazonaws.com/bucketName");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://amazonaws.com/bucketName")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3".to_string().into());
                         out.insert("signingRegion".to_string(), "snow".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3".to_string())
                         .put("signingRegion", "snow".to_string())
-6797
+                )
                 .build()
         );
-6800
+    }
-6801
     /// Data Plane with short zone name
     #[test]
     fn test_275() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("mybucket--abcd-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-6826
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-6830
+    }
-6831
     /// Data Plane with short zone name china region
     #[test]
     fn test_276() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-1".to_string())
             .bucket("mybucket--abcd-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-6856
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-6860
+    }
-6861
     /// Data Plane with short zone name with AP
     #[test]
     fn test_277() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("myaccesspoint--abcd-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-6886
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-6890
+    }
-6891
     /// Data Plane with short zone name with AP china region
     #[test]
     fn test_278() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-1".to_string())
             .bucket("myaccesspoint--abcd-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-6917
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-6921
+    }
-6922
     /// Data Plane with short zone names (13 chars)
     #[test]
     fn test_279() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-6948
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-6952
+    }
-6953
     /// Data Plane with short zone names (13 chars) with AP
     #[test]
     fn test_280() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-6979
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-6983
+    }
-6984
     /// Data Plane with medium zone names (14 chars)
     #[test]
     fn test_281() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7010
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7014
+    }
-7015
     /// Data Plane with medium zone names (14 chars) with AP
     #[test]
     fn test_282() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7041
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7045
+    }
-7046
     /// Data Plane with long zone names (20 chars)
     #[test]
     fn test_283() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7072
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7076
+    }
-7077
     /// Data Plane with long zone names (20 chars)
     #[test]
     fn test_284() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7104
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7108
+    }
-7109
     /// Data Plane with short zone fips
     #[test]
     fn test_285() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("mybucket--test-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-7134
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7138
+    }
-7139
     /// Data Plane with short zone fips china region
     #[test]
     fn test_286() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-1".to_string())
             .bucket("mybucket--test-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [Data Plane with short zone fips china region]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-7156
+    }
-7157
     /// Data Plane with short zone fips with AP
     #[test]
     fn test_287() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-ab1--xa-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test-ab1--xa-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-7183
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7187
+    }
-7188
     /// Data Plane with short zone fips with AP china region
     #[test]
     fn test_288() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-1".to_string())
             .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [Data Plane with short zone fips with AP china region]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-7205
+    }
-7206
     /// Data Plane with short zone (13 chars) fips
     #[test]
     fn test_289() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7232
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7236
+    }
-7237
     /// Data Plane with short zone (13 chars) fips with AP
     #[test]
     fn test_290() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7263
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7267
+    }
-7268
     /// Data Plane with medium zone (14 chars) fips
     #[test]
     fn test_291() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7294
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7298
+    }
-7299
     /// Data Plane with medium zone (14 chars) fips with AP
     #[test]
     fn test_292() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7325
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7329
+    }
-7330
     /// Data Plane with long zone (20 chars) fips
     #[test]
     fn test_293() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7357
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7361
+    }
-7362
     /// Data Plane with long zone (20 chars) fips with AP
     #[test]
     fn test_294() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7389
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7393
+    }
-7394
     /// Data Plane with long AZ
     #[test]
     fn test_295() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-az1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7419
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7423
+    }
-7424
     /// Data Plane with long AZ with AP
     #[test]
     fn test_296() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7450
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7454
+    }
-7455
     /// Data Plane with long AZ fips
     #[test]
     fn test_297() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-az1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7480
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7484
+    }
-7485
     /// Data Plane with long AZ fips with AP
     #[test]
     fn test_298() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7511
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7515
+    }
-7516
     /// Control plane with short AZ bucket
     #[test]
     fn test_299() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("mybucket--test-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-7542
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7546
+    }
-7547
     /// Control plane with short AZ bucket china region
     #[test]
     fn test_300() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-1".to_string())
             .bucket("mybucket--test-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.cn-north-1.amazonaws.com.cn/mybucket--test-ab1--x-s3");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control.cn-north-1.amazonaws.com.cn/mybucket--test-ab1--x-s3")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-7573
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7577
+    }
-7578
     /// Control plane with short AZ bucket and fips
     #[test]
     fn test_301() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("mybucket--test-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-7604
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7608
+    }
-7609
     /// Control plane with short AZ bucket and fips china region
     #[test]
     fn test_302() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-1".to_string())
             .bucket("mybucket--test-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Partition does not support FIPS [Control plane with short AZ bucket and fips china region]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-7627
+    }
-7628
     /// Control plane without bucket
     #[test]
     fn test_303() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-7653
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7657
+    }
-7658
     /// Control plane without bucket and fips
     #[test]
     fn test_304() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control-fips.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-7683
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7687
+    }
-7688
     /// Data Plane sigv4 auth with short AZ
     #[test]
     fn test_305() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7713
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7717
+    }
-7718
     /// Data Plane sigv4 auth with short AZ with AP
     #[test]
     fn test_306() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7743
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7747
+    }
-7748
     /// Data Plane sigv4 auth with short zone (13 chars)
     #[test]
     fn test_307() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7774
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7778
+    }
-7779
     /// Data Plane sigv4 auth with short zone (13 chars) with AP
     #[test]
     fn test_308() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7805
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7809
+    }
-7810
     /// Data Plane sigv4 auth with short AZ fips
     #[test]
     fn test_309() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7835
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7839
+    }
-7840
     /// Data Plane sigv4 auth with short AZ fips with AP
     #[test]
     fn test_310() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7866
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7870
+    }
-7871
     /// Data Plane sigv4 auth with short zone (13 chars) fips
     #[test]
     fn test_311() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7897
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7901
+    }
-7902
     /// Data Plane sigv4 auth with short zone (13 chars) fips with AP
     #[test]
     fn test_312() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7928
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7932
+    }
-7933
     /// Data Plane sigv4 auth with long AZ
     #[test]
     fn test_313() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-az1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7959
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7963
+    }
-7964
     /// Data Plane sigv4 auth with long AZ with AP
     #[test]
     fn test_314() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-7991
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-7995
+    }
-7996
     /// Data Plane sigv4 auth with medium zone(14 chars)
     #[test]
     fn test_315() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8023
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8027
+    }
-8028
     /// Data Plane sigv4 auth with medium zone(14 chars) with AP
     #[test]
     fn test_316() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8055
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8059
+    }
-8060
     /// Data Plane sigv4 auth with long zone(20 chars)
     #[test]
     fn test_317() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8087
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8091
+    }
-8092
     /// Data Plane sigv4 auth with long zone(20 chars) with AP
     #[test]
     fn test_318() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8120
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8124
+    }
-8125
     /// Data Plane sigv4 auth with long AZ fips
     #[test]
     fn test_319() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-az1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8151
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8155
+    }
-8156
     /// Data Plane sigv4 auth with long AZ fips with AP
     #[test]
     fn test_320() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8183
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8187
+    }
-8188
     /// Data Plane sigv4 auth with medium zone (14 chars) fips
     #[test]
     fn test_321() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8215
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8219
+    }
-8220
     /// Data Plane sigv4 auth with medium zone (14 chars) fips with AP
     #[test]
     fn test_322() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8247
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8251
+    }
-8252
     /// Data Plane sigv4 auth with long zone (20 chars) fips
     #[test]
     fn test_323() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8280
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8284
+    }
-8285
     /// Data Plane sigv4 auth with long zone (20 chars) fips with AP
     #[test]
     fn test_324() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8313
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8317
+    }
-8318
     /// Control Plane host override
     #[test]
     fn test_325() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(true)
             .endpoint("https://custom.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az1--x-s3.custom.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8345
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8349
+    }
-8350
     /// Control Plane host override with AP
     #[test]
     fn test_326() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(true)
             .endpoint("https://custom.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.custom.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az1--xa-s3.custom.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8377
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8381
+    }
-8382
     /// Control Plane host override no bucket
     #[test]
     fn test_327() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(true)
             .endpoint("https://custom.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://custom.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://custom.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8408
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8412
+    }
-8413
     /// Data plane host override non virtual session auth
     #[test]
     fn test_328() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .endpoint("https://10.0.0.1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8438
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8442
+    }
-8443
     /// Data plane host override non virtual session auth with AP
     #[test]
     fn test_329() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .endpoint("https://10.0.0.1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8468
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8472
+    }
-8473
     /// Control Plane host override ip
     #[test]
     fn test_330() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(true)
             .endpoint("https://10.0.0.1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8500
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8504
+    }
-8505
     /// Control Plane host override ip with AP
     #[test]
     fn test_331() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(true)
             .endpoint("https://10.0.0.1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8532
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8536
+    }
-8537
     /// Data plane host override
     #[test]
     fn test_332() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .endpoint("https://custom.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az1--x-s3.custom.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8562
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8566
+    }
-8567
     /// Data plane host override with AP
     #[test]
     fn test_333() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .endpoint("https://custom.com".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.custom.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az1--xa-s3.custom.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8592
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8596
+    }
-8597
     /// bad format error
     #[test]
     fn test_334() {
         let params = crate::config::endpoint::Params::builder()

↧ Expand context

             .region("us-east-1".to_string())
             .bucket("mybucket--usaz1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(false)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error]");
         assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
-8614
+    }
-8615
     /// bad AP format error
     #[test]
     fn test_335() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("myaccesspoint--usaz1--xa-s3".to_string())

@@ -10190,8814 +15377,14190 @@

↥ Expand context

             .endpoint("https://custom.com".to_string())
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error =
             endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error]");
         assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
-8823
+    }
-8824
     /// Control plane without bucket and dualstack
     #[test]
     fn test_346() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)

             .disable_s3_express_session_auth(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-8849
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8853
+    }
-8854
     /// Control plane without bucket, fips and dualstack
     #[test]
     fn test_347() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .disable_s3_express_session_auth(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-8879
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8883
+    }
-8884
     /// Data Plane with short AZ and dualstack
     #[test]
     fn test_348() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8910
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8914
+    }
-8915
     /// Data Plane with short AZ and FIPS with dualstack
     #[test]
     fn test_349() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8941
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8945
+    }
-8946
     /// Data Plane sigv4 auth with short AZ and dualstack
     #[test]
     fn test_350() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-8972
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-8976
+    }
-8977
     /// Data Plane sigv4 auth with short AZ and FIPS with dualstack
     #[test]
     fn test_351() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9003
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9007
+    }
-9008
     /// Data Plane with zone and dualstack
     #[test]
     fn test_352() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az12--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9034
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9038
+    }
-9039
     /// Data Plane with zone and FIPS with dualstack
     #[test]
     fn test_353() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az12--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9065
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9069
+    }
-9070
     /// Data Plane sigv4 auth with zone and dualstack
     #[test]
     fn test_354() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az12--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9096
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9100
+    }
-9101
     /// Data Plane sigv4 auth with 9-char zone and FIPS with dualstack
     #[test]
     fn test_355() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--usw2-az12--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9127
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9131
+    }
-9132
     /// Data Plane with 13-char zone and dualstack
     #[test]
     fn test_356() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9158
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9162
+    }
-9163
     /// Data Plane with 13-char zone and FIPS with dualstack
     #[test]
     fn test_357() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9189
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9193
+    }
-9194
     /// Data Plane sigv4 auth with 13-char zone and dualstack
     #[test]
     fn test_358() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9220
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9224
+    }
-9225
     /// Data Plane sigv4 auth with 13-char zone and FIPS with dualstack
     #[test]
     fn test_359() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9251
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9255
+    }
-9256
     /// Data Plane with 14-char zone and dualstack
     #[test]
     fn test_360() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9282
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9286
+    }
-9287
     /// Data Plane with 14-char zone and FIPS with dualstack
     #[test]
     fn test_361() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9314
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9318
+    }
-9319
     /// Data Plane sigv4 auth with 14-char zone and dualstack
     #[test]
     fn test_362() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9345
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9349
+    }
-9350
     /// Data Plane sigv4 auth with 14-char zone and FIPS with dualstack
     #[test]
     fn test_363() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9377
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9381
+    }
-9382
     /// Data Plane with long zone (20 cha) and dualstack
     #[test]
     fn test_364() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9409
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9413
+    }
-9414
     /// Data Plane with long zone (20 char) and FIPS with dualstack
     #[test]
     fn test_365() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9439
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9443
+    }
-9444
     /// Data Plane sigv4 auth with long zone (20 char) and dualstack
     #[test]
     fn test_366() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9471
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9475
+    }
-9476
     /// Data Plane sigv4 auth with long zone (20 char) and FIPS with dualstack
     #[test]
     fn test_367() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9501
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9505
+    }
-9506
     /// Control plane and FIPS with dualstack
     #[test]
     fn test_368() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("mybucket--test-ab1--x-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-9532
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9536
+    }
-9537
     /// Data plane with zone and dualstack and AP
     #[test]
     fn test_369() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9563
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9567
+    }
-9568
     /// Data plane with zone and FIPS with dualstack and AP
     #[test]
     fn test_370() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9594
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9598
+    }
-9599
     /// Data Plane sigv4 auth with zone and dualstack and AP
     #[test]
     fn test_371() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9625
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9629
+    }
-9630
     /// Data Plane AP sigv4 auth with zone and FIPS with dualstack
     #[test]
     fn test_372() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9656
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9660
+    }
-9661
     /// Data Plane with zone (9 char) and AP with dualstack
     #[test]
     fn test_373() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9687
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9691
+    }
-9692
     /// Data Plane with zone (9 char) and FIPS with AP and dualstack
     #[test]
     fn test_374() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9718
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9722
+    }
-9723
     /// Data Plane sigv4 auth with (9 char) zone and dualstack with AP
     #[test]
     fn test_375() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9749
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9753
+    }
-9754
     /// Access Point sigv4 auth with (9 char) zone and FIPS with dualstack
     #[test]
     fn test_376() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9780
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9784
+    }
-9785
     /// Data Plane with zone (13 char) and AP with dualstack
     #[test]
     fn test_377() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9811
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9815
+    }
-9816
     /// Data Plane with zone (13 char) and AP with FIPS and dualstack
     #[test]
     fn test_378() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9843
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9847
+    }
-9848
     /// Data Plane sigv4 auth with (13 char) zone with AP and dualstack
     #[test]
     fn test_379() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint
             .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9874
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9878
+    }
-9879
     /// Data Plane sigv4 auth with (13 char) zone with AP and FIPS and dualstack
     #[test]
     fn test_380() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9906
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9910
+    }
-9911
     /// Data Plane with (14 char) zone and AP with dualstack
     #[test]
     fn test_381() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9938
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9942
+    }
-9943
     /// Data Plane with (14 char) zone and AP with FIPS and dualstack
     #[test]
     fn test_382() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-9970
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-9974
+    }
-9975
     /// Data Plane sigv4 auth with (14 char) zone and AP with dualstack
     #[test]
     fn test_383() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-10002
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-10006
+    }
-10007
     /// Data Plane with (14 char) zone and AP with FIPS and dualstack
     #[test]
     fn test_384() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect(
             "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
         );
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-10034
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-10038
+    }
-10039
     /// Data Plane with (20 char) zone and AP with dualstack
     #[test]
     fn test_385() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-10064
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-10068
+    }
-10069
     /// Data Plane with (20 char) zone and AP with FIPS and dualstack
     #[test]
     fn test_386() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(false)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4-s3express".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-10094
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-10098
+    }
-10099
     /// Data plane AP with sigv4 and dualstack
     #[test]
     fn test_387() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-10124
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-10128
+    }
-10129
     /// Data plane AP sigv4 with fips and dualstack
     #[test]
     fn test_388() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-west-2".to_string())
             .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
             .use_fips(true)
             .use_dual_stack(true)
             .accelerate(false)
             .disable_s3_express_session_auth(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-10154
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-10158
+    }
-10159
     /// Control plane with dualstack and bucket
     #[test]
     fn test_389() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .bucket("mybucket--test-ab1--x-s3".to_string())
             .use_fips(false)
             .use_dual_stack(true)
             .accelerate(false)
             .use_s3_express_control_endpoint(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint =
             endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "s3express".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out.insert("disableDoubleEncoding".to_string(), true.into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3express".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-10185
+                )
                 .property("backend", "S3Express".to_string())
                 .build()
         );
-10189
+    }
-10190
+}
-10191
 /// Endpoint resolver trait specific to Amazon Simple Storage Service
 pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
     /// Resolve an endpoint with the given parameters
     fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
-10196
     /// Convert this service-specific resolver into a `SharedEndpointResolver`
     ///
     /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
     fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
     where
         Self: Sized + 'static,
-10203
+    {
         ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
-10205
+    }
-10206
+}
-10207
 #[derive(Debug)]
 struct DowncastParams<T>(T);
 impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
 where
     T: ResolveEndpoint,
-10213
+{
     fn resolve_endpoint<'a>(
         &'a self,
         params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
     ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
         let ep = match params.get::<crate::config::endpoint::Params>() {
             Some(params) => self.0.resolve_endpoint(params),
             None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
         };
         ep
-10223
+    }
-10224
+}
-10225
 #[derive(Debug)]
 /// The default endpoint resolver.
 pub struct DefaultResolver {
     partition_resolver: &'static crate::endpoint_lib::partition::PartitionResolver,
     endpoint_cache: ::std::sync::Mutex<::std::option::Option<(Params, ::aws_smithy_types::endpoint::Endpoint)>>,
-10231
+}
-10232
 impl Default for DefaultResolver {
     fn default() -> Self {
         Self::new()
-10236
+    }
-10237
+}
-10238
 impl DefaultResolver {
     /// Create a new DefaultResolver
     pub fn new() -> Self {
         Self {
             partition_resolver: &crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER,
             endpoint_cache: ::std::sync::Mutex::new(None),
-10245
+        }
-10246
+    }
-10247
     #[allow(clippy::needless_borrow)]
     pub(crate) fn evaluate_fn(
         &self,
     ) -> impl for<'a> FnMut(&ConditionFn, &'a Params, &mut ConditionContext<'a>, &mut crate::endpoint_lib::diagnostic::DiagnosticCollector) -> bool + '_
--
+    {
         move |cond, params, context, _diagnostic_collector| cond.evaluate(params, context, &self.partition_resolver, _diagnostic_collector)
--
+    }
--
     fn resolve_endpoint<'a>(
         &'a self,
         params: &'a crate::config::endpoint::Params,
     ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
         let mut diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
         let mut condition_context = ConditionContext::default();
         let result = crate::endpoint_lib::bdd_interpreter::evaluate_bdd(
             &NODES,
             &CONDITIONS,
             &RESULTS,
 ,
             params,
             &mut condition_context,
             &mut diagnostic_collector,
             self.evaluate_fn(),
         );
--
         match result {
             ::std::option::Option::Some(endpoint) => match endpoint.to_endpoint(params, &condition_context) {
                 Ok(ep) => Ok(ep),
                 Err(err) => Err(Box::new(err)),
             },
             ::std::option::Option::None => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "No endpoint rule matched",
             ))),
--
+        }
--
+    }
--
+}
--
 impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
     fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
         let result = self.resolve_endpoint(params);
--
         ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(result)
--
+    }
--
+}
 #[derive(Debug)]
 pub(crate) enum ConditionFn {
     Cond0,
     Cond1,
     Cond2,
     Cond3,
     Cond4,
     Cond5,
     Cond6,
     Cond7,
     Cond8,
     Cond9,
     Cond10,
     Cond11,
     Cond12,
     Cond13,
     Cond14,
     Cond15,
     Cond16,
     Cond17,
     Cond18,
     Cond19,
     Cond20,
     Cond21,
     Cond22,
     Cond23,
     Cond24,
     Cond25,
     Cond26,
     Cond27,
     Cond28,
     Cond29,
     Cond30,
     Cond31,
     Cond32,
     Cond33,
     Cond34,
     Cond35,
     Cond36,
     Cond37,
     Cond38,
     Cond39,
     Cond40,
     Cond41,
     Cond42,
     Cond43,
     Cond44,
     Cond45,
     Cond46,
     Cond47,
     Cond48,
     Cond49,
     Cond50,
     Cond51,
     Cond52,
     Cond53,
     Cond54,
     Cond55,
     Cond56,
     Cond57,
     Cond58,
     Cond59,
     Cond60,
     Cond61,
     Cond62,
     Cond63,
     Cond64,
     Cond65,
     Cond66,
     Cond67,
     Cond68,
     Cond69,
     Cond70,
     Cond71,
     Cond72,
     Cond73,
     Cond74,
     Cond75,
--
+}
--
 impl ConditionFn {
     #[allow(
         unused_variables,
         unused_parens,
         clippy::double_parens,
         clippy::useless_conversion,
         clippy::bool_comparison,
         clippy::comparison_to_empty,
         clippy::needless_borrow,
         clippy::useless_asref
     )]
     fn evaluate<'a>(
         &self,
         params: &'a Params,
         context: &mut ConditionContext<'a>,
         partition_resolver: &'a crate::endpoint_lib::partition::PartitionResolver,
         _diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector,
     ) -> bool {
     fn resolve_endpoint<'a>(
         &'a self,
         params: &'a crate::config::endpoint::Params,
     ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
         let mut _diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
         let mut context = ConditionContext::default();
-+
         // Param bindings
         let bucket = &params.bucket;
         let region = &params.region;
         let use_fips = &params.use_fips;
         let use_dual_stack = &params.use_dual_stack;
         let endpoint = &params.endpoint;
         let force_path_style = &params.force_path_style;
         let accelerate = &params.accelerate;
         let use_global_endpoint = &params.use_global_endpoint;
         let use_object_lambda_endpoint = &params.use_object_lambda_endpoint;
         let key = &params.key;
         let prefix = &params.prefix;
         let copy_source = &params.copy_source;
         let disable_access_points = &params.disable_access_points;
         let disable_multi_region_access_points = &params.disable_multi_region_access_points;
         let use_arn_region = &params.use_arn_region;
         let use_s3_express_control_endpoint = &params.use_s3_express_control_endpoint;
         let disable_s3_express_session_auth = &params.disable_s3_express_session_auth;
-10283
         // Non-Param references
         let effective_std_region = &mut context.effective_std_region;
         let partition_result = &mut context.partition_result;
         let url = &mut context.url;
         let access_point_suffix = &mut context.access_point_suffix;
         let region_prefix = &mut context.region_prefix;
         let hardware_type = &mut context.hardware_type;
         let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
         let s3_e_ds = &mut context.s3_e_ds;
         let s3_e_fips = &mut context.s3_e_fips;
         let s3_e_auth = &mut context.s3_e_auth;
         let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
         let bucket_arn = &mut context.bucket_arn;
         let effective_arn_region = &mut context.effective_arn_region;
         let uri_encoded_bucket = &mut context.uri_encoded_bucket;
         let arn_type = &mut context.arn_type;
         let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
         let bucket_partition = &mut context.bucket_partition;
         let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
         let outpost_type = &mut context.outpost_type;
         let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
         match self {
             Self::Cond0 => region.is_some(),
             Self::Cond1 => {
                 *effective_std_region = Some(
                     crate::endpoint_lib::ite::ite!(
                         (region) == &mut Some(("aws-global".into())),
                         "us-east-1".to_string(),
                         region.clone().expect("Reference already confirmed Some")
         let mut current_ref: i32 = 521;
         loop {
             match current_ref {
                 ref_val if ref_val >= 100_000_000 => {
                     return match (ref_val - 100_000_000) as usize {
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "No endpoint rule matched",
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Accelerate cannot be used with FIPS".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Cannot set dual-stack in combination with a custom endpoint.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "A custom endpoint cannot be combined with FIPS".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "A custom endpoint cannot be combined with S3 Accelerate".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Partition does not support FIPS".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3Express does not support S3 Accelerate.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let uri_encoded_bucket = context
                                 .uri_encoded_bucket
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                                         out.push('/');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&uri_encoded_bucket.as_ref());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.path());
                                         out
                                     })
                                     .property("backend", "S3Express".to_string())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3express")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10343
+                                    )
                     .into(),
                 );
                 true
--
+            }
             Self::Cond2 => (accelerate) == (&true),
             Self::Cond3 => (use_fips) == (&true),
             Self::Cond4 => endpoint.is_some(),
             Self::Cond5 => (use_dual_stack) == (&true),
             Self::Cond6 => bucket.is_some(),
             Self::Cond7 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--x-s3")
--
+            }
             Self::Cond8 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--xa-s3")
--
+            }
             Self::Cond9 => {
                 *partition_result = partition_resolver
                     .resolve_partition(if let Some(param) = region { param } else { return false }, _diagnostic_collector)
                     .map(|inner| inner.into());
                 partition_result.is_some()
--
+            }
             Self::Cond10 => {
                 *url =
                     crate::endpoint_lib::parse_url::parse_url(if let Some(param) = endpoint { param } else { return false }, _diagnostic_collector)
                         .map(|inner| inner.into());
                 url.is_some()
--
+            }
             Self::Cond11 => {
                 *access_point_suffix = crate::endpoint_lib::substring::substring(
                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                     true,
                     _diagnostic_collector,
                                     .build(),
-10345
+                            )
                 .map(|inner| inner.into());
                 access_point_suffix.is_some()
-10346
+                        }
             Self::Cond12 => (access_point_suffix) == &mut Some(("--op-s3".into())),
             Self::Cond13 => {
                 *region_prefix = crate::endpoint_lib::substring::substring(
                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                     true,
                     _diagnostic_collector,
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.path());
                                         out
                                     })
                                     .property("backend", "S3Express".to_string())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3express")
                                             .put("signingRegion", effective_std_region.as_ref()),
-+
+                                    )
                                     .build(),
-10379
+                            )
                 .map(|inner| inner.into());
                 region_prefix.is_some()
-10380
+                        }
             Self::Cond14 => {
                 *hardware_type = crate::endpoint_lib::substring::substring(
                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                     true,
                     _diagnostic_collector,
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3Express bucket name is not a valid virtual hostable name.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_ds = context.s3_e_ds.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_fips = context.s3_e_fips.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let uri_encoded_bucket = context
                                 .uri_encoded_bucket
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://s3express-control");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&s3_e_fips.as_ref());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&s3_e_ds.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out.push('/');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                                     .property("backend", "S3Express".to_string())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3express")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10422
+                                    )
                 .map(|inner| inner.into());
                 hardware_type.is_some()
--
+            }
             Self::Cond15 => {
                 *outpost_id_ssa_2 = crate::endpoint_lib::substring::substring(
                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                     true,
                     _diagnostic_collector,
                                     .build(),
-10424
+                            )
                 .map(|inner| inner.into());
                 outpost_id_ssa_2.is_some()
--
+            }
             Self::Cond16 => {
                 (if let Some(inner) = partition_result {
                     inner.name()
                 } else {
                     return false;
                 }) == ("aws-cn")
-10425
+                        }
             Self::Cond17 => {
                 *s3_e_ds = Some(crate::endpoint_lib::ite::ite!(use_dual_stack, ".dualstack".to_string(), "".to_string()).into());
                 true
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_ds = context.s3_e_ds.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_fips = context.s3_e_fips.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3express_availability_zone_id = context
                                 .s3express_availability_zone_id
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                                         out.push_str(".s3express");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&s3_e_fips.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&s3express_availability_zone_id.as_ref());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&s3_e_ds.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                                     .property("backend", "S3Express".to_string())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3express")
                                             .put("signingRegion", effective_std_region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-10472
+                        }
             Self::Cond18 => {
                 *s3_e_fips = Some(crate::endpoint_lib::ite::ite!(use_fips, "-fips".to_string(), "".to_string()).into());
                 true
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Unrecognized S3Express bucket name format.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.path());
                                         out
                                     })
                                     .property("backend", "S3Express".to_string())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3express")
                                             .put("signingRegion", effective_std_region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-10505
+                        }
             Self::Cond19 => (force_path_style) == (&true),
             Self::Cond20 => {
                 *s3_e_auth = Some(
                     crate::endpoint_lib::ite::ite!(
                         crate::endpoint_lib::coalesce::coalesce!(*disable_s3_express_session_auth, false),
                         "sigv4".to_string(),
                         "sigv4-s3express".to_string()
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_ds = context.s3_e_ds.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let s3_e_fips = context.s3_e_fips.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://s3express-control");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&s3_e_fips.as_ref());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&s3_e_ds.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                                     .property("backend", "S3Express".to_string())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3express")
                                             .put("signingRegion", effective_std_region.as_ref()),
-+
+                                    )
                                     .build(),
-10539
+                            )
                     .into(),
                 );
                 true
-10540
+                        }
             Self::Cond21 => crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
                 if let Some(param) = bucket { param } else { return false },
                 false,
                 _diagnostic_collector,
             ),
             Self::Cond22 => {
                 *s3express_availability_zone_id = crate::endpoint_lib::split::split(
                     if let Some(param) = bucket { param } else { return false },
                     "--",
 ,
                     _diagnostic_collector,
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Expected a endpoint to be specified but no endpoint was found".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                                         out.push_str(".ec2.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                                         out
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
-+
+                                    )
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", effective_std_region.as_ref()),
-+
+                                    )
                                     .build(),
-10576
+                            )
                 .get(1)
                 .cloned()
                 .map(|inner| inner.into());
                 s3express_availability_zone_id.is_some()
-10577
+                        }
             Self::Cond23 => crate::endpoint_lib::host::is_valid_host_label(
                 if let Some(param) = outpost_id_ssa_2 { param } else { return false },
                 false,
                 _diagnostic_collector,
             ),
             Self::Cond24 => (crate::endpoint_lib::coalesce::coalesce!(*use_s3_express_control_endpoint, false)) == (true),
             Self::Cond25 => (region_prefix) == &mut Some(("beta".into())),
             Self::Cond26 => crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
                 if let Some(param) = bucket { param } else { return false },
                 true,
                 _diagnostic_collector,
             ),
             Self::Cond27 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--")
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                                         out.push_str(".ec2.s3-outposts.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
-+
+                                    )
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", effective_std_region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-10614
+                        }
             Self::Cond28 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--")
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                                         out.push_str(".op-");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&outpost_id_ssa_2.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                                         out
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
-+
+                                    )
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", effective_std_region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-10652
+                        }
             Self::Cond29 => (if let Some(inner) = url { inner.scheme() } else { return false }) == ("http"),
             Self::Cond30 => crate::endpoint_lib::host::is_valid_host_label(
                 if let Some(param) = region { param } else { return false },
                 false,
                 _diagnostic_collector,
             ),
             Self::Cond31 => {
                 *bucket_arn = crate::endpoint_lib::arn::parse_arn(if let Some(param) = bucket { param } else { return false }, _diagnostic_collector)
                     .map(|inner| inner.into());
                 bucket_arn.is_some()
--
+            }
             Self::Cond32 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--")
--
+            }
             Self::Cond33 => {
                 *effective_arn_region = Some(
                     crate::endpoint_lib::ite::ite!(
                         crate::endpoint_lib::coalesce::coalesce!(*use_arn_region, true),
                         if let Some(inner) = bucket_arn { inner.region() } else { return false }.to_string(),
                         region.clone().expect("Reference already confirmed Some")
--
+                    )
                     .into(),
                 );
                 true
--
+            }
             Self::Cond34 => (if let Some(inner) = url { inner.is_ip() } else { return false }) == (true),
             Self::Cond35 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         false,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("arn:")
--
+            }
             Self::Cond36 => {
                 *uri_encoded_bucket = Some(
                     crate::endpoint_lib::uri_encode::uri_encode(if let Some(param) = bucket { param } else { return false }, _diagnostic_collector)
                         .into(),
                 );
                 true
--
+            }
             Self::Cond37 => (crate::endpoint_lib::coalesce::coalesce!(*use_object_lambda_endpoint, false)) == (true),
             Self::Cond38 => {
                 *arn_type = if let Some(inner) = bucket_arn {
                     inner.resource_id().first().cloned()
                 } else {
                     return false;
--
+                }
                 .map(|inner| inner.into());
                 arn_type.is_some()
--
+            }
             Self::Cond39 => (arn_type) == &mut Some(("".into())),
             Self::Cond40 => (arn_type) == &mut Some(("accesspoint".into())),
             Self::Cond41 => {
                 *access_point_name_ssa_1 = if let Some(inner) = bucket_arn {
                     inner.resource_id().get(1).cloned()
                 } else {
                     return false;
--
+                }
                 .map(|inner| inner.into());
                 access_point_name_ssa_1.is_some()
--
+            }
             Self::Cond42 => (access_point_name_ssa_1) == &mut Some(("".into())),
             Self::Cond43 => (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-object-lambda"),
             Self::Cond44 => crate::endpoint_lib::host::is_valid_host_label(
                 if let Some(param) = region { param } else { return false },
                 true,
                 _diagnostic_collector,
             ),
             Self::Cond45 => (if let Some(inner) = bucket_arn { inner.region() } else { return false }) == (""),
             Self::Cond46 => (hardware_type) == &mut Some(("e".into())),
             Self::Cond47 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--")
--
+            }
             Self::Cond48 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--")
--
+            }
             Self::Cond49 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--")
--
+            }
             Self::Cond50 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--")
--
+            }
             Self::Cond51 => {
                 (crate::endpoint_lib::coalesce::coalesce!(
                     if let Some(inner) = crate::endpoint_lib::substring::substring(
                         if let Some(param) = bucket { param } else { return false },
 ,
 ,
                         true,
                         _diagnostic_collector
                     ) {
                         inner
                     } else {
                         return false;
                     },
                     ""
                 )) == ("--")
--
+            }
             Self::Cond52 => (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-outposts"),
             Self::Cond53 => (crate::endpoint_lib::coalesce::coalesce!(*disable_access_points, false)) == (true),
             Self::Cond54 => {
                 *bucket_partition = partition_resolver
                     .resolve_partition(
                         if let Some(param) = effective_arn_region { param } else { return false },
                         _diagnostic_collector,
--
+                    )
                     .map(|inner| inner.into());
                 bucket_partition.is_some()
--
+            }
             Self::Cond55 => (hardware_type) == &mut Some(("o".into())),
             Self::Cond56 => if let Some(inner) = bucket_arn {
                 inner.resource_id().get(4).cloned()
             } else {
                 return false;
--
+            }
             .is_some(),
             Self::Cond57 => {
                 *outpost_id_ssa_1 = if let Some(inner) = bucket_arn {
                     inner.resource_id().get(1).cloned()
                 } else {
                     return false;
--
+                }
                 .map(|inner| inner.into());
                 outpost_id_ssa_1.is_some()
--
+            }
             Self::Cond58 => (crate::endpoint_lib::coalesce::coalesce!(*use_arn_region, true)) == (true),
             Self::Cond59 => (effective_arn_region) == &mut Some((if let Some(inner) = bucket_arn { inner.region() } else { return false }.into())),
             Self::Cond60 => (region) == &mut Some(("aws-global".into())),
             Self::Cond61 => (use_global_endpoint) == (&true),
             Self::Cond62 => (disable_multi_region_access_points) == (&true),
             Self::Cond63 => (region) == &mut Some(("us-east-1".into())),
             Self::Cond64 => crate::endpoint_lib::host::is_valid_host_label(
                 if let Some(param) = outpost_id_ssa_1 { param } else { return false },
                 false,
                 _diagnostic_collector,
             ),
             Self::Cond65 => {
                 *outpost_type = if let Some(inner) = bucket_arn {
                     inner.resource_id().get(2).cloned()
                 } else {
                     return false;
--
+                }
                 .map(|inner| inner.into());
                 outpost_type.is_some()
--
+            }
             Self::Cond66 => {
                 (if let Some(inner) = bucket_partition {
                     inner.name()
                 } else {
                     return false;
                 }) == (if let Some(inner) = partition_result {
                     inner.name()
                 } else {
                     return false;
                 })
--
+            }
             Self::Cond67 => crate::endpoint_lib::host::is_valid_host_label(
                 if let Some(param) = effective_arn_region { param } else { return false },
                 true,
                 _diagnostic_collector,
             ),
             Self::Cond68 => (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3"),
             Self::Cond69 => {
                 (if let Some(inner) = bucket_arn {
                     inner.account_id()
                 } else {
                     return false;
                 }) == ("")
--
+            }
             Self::Cond70 => crate::endpoint_lib::host::is_valid_host_label(
                 if let Some(inner) = bucket_arn {
                     inner.account_id()
                 } else {
                     return false;
                 },
                 false,
                 _diagnostic_collector,
             ),
             Self::Cond71 => crate::endpoint_lib::host::is_valid_host_label(
                 if let Some(param) = access_point_name_ssa_1 {
                     param
                 } else {
                     return false;
                 },
                 false,
                 _diagnostic_collector,
             ),
             Self::Cond72 => {
                 *access_point_name_ssa_2 = if let Some(inner) = bucket_arn {
                     inner.resource_id().get(3).cloned()
                 } else {
                     return false;
--
+                }
                 .map(|inner| inner.into());
                 access_point_name_ssa_2.is_some()
--
+            }
             Self::Cond73 => crate::endpoint_lib::host::is_valid_host_label(
                 if let Some(param) = access_point_name_ssa_1 {
                     param
                 } else {
                     return false;
                 },
                 true,
                 _diagnostic_collector,
             ),
             Self::Cond74 => {
                 (if let Some(inner) = bucket_arn { inner.partition() } else { return false })
                     == (if let Some(inner) = partition_result {
                         inner.name()
                     } else {
                         return false;
                     })
--
+            }
             Self::Cond75 => (outpost_type) == &mut Some(("accesspoint".into())),
--
+        }
--
+    }
--
+}
--
 const CONDITIONS: [ConditionFn; 76] = [
     ConditionFn::Cond0,
     ConditionFn::Cond1,
     ConditionFn::Cond2,
     ConditionFn::Cond3,
     ConditionFn::Cond4,
     ConditionFn::Cond5,
     ConditionFn::Cond6,
     ConditionFn::Cond7,
     ConditionFn::Cond8,
     ConditionFn::Cond9,
     ConditionFn::Cond10,
     ConditionFn::Cond11,
     ConditionFn::Cond12,
     ConditionFn::Cond13,
     ConditionFn::Cond14,
     ConditionFn::Cond15,
     ConditionFn::Cond16,
     ConditionFn::Cond17,
     ConditionFn::Cond18,
     ConditionFn::Cond19,
     ConditionFn::Cond20,
     ConditionFn::Cond21,
     ConditionFn::Cond22,
     ConditionFn::Cond23,
     ConditionFn::Cond24,
     ConditionFn::Cond25,
     ConditionFn::Cond26,
     ConditionFn::Cond27,
     ConditionFn::Cond28,
     ConditionFn::Cond29,
     ConditionFn::Cond30,
     ConditionFn::Cond31,
     ConditionFn::Cond32,
     ConditionFn::Cond33,
     ConditionFn::Cond34,
     ConditionFn::Cond35,
     ConditionFn::Cond36,
     ConditionFn::Cond37,
     ConditionFn::Cond38,
     ConditionFn::Cond39,
     ConditionFn::Cond40,
     ConditionFn::Cond41,
     ConditionFn::Cond42,
     ConditionFn::Cond43,
     ConditionFn::Cond44,
     ConditionFn::Cond45,
     ConditionFn::Cond46,
     ConditionFn::Cond47,
     ConditionFn::Cond48,
     ConditionFn::Cond49,
     ConditionFn::Cond50,
     ConditionFn::Cond51,
     ConditionFn::Cond52,
     ConditionFn::Cond53,
     ConditionFn::Cond54,
     ConditionFn::Cond55,
     ConditionFn::Cond56,
     ConditionFn::Cond57,
     ConditionFn::Cond58,
     ConditionFn::Cond59,
     ConditionFn::Cond60,
     ConditionFn::Cond61,
     ConditionFn::Cond62,
     ConditionFn::Cond63,
     ConditionFn::Cond64,
     ConditionFn::Cond65,
     ConditionFn::Cond66,
     ConditionFn::Cond67,
     ConditionFn::Cond68,
     ConditionFn::Cond69,
     ConditionFn::Cond70,
     ConditionFn::Cond71,
     ConditionFn::Cond72,
     ConditionFn::Cond73,
     ConditionFn::Cond74,
     ConditionFn::Cond75,
 ];
 #[derive(Debug, Clone)]
 enum ResultEndpoint {
     Result0,
     Result1,
     Result2,
     Result3,
     Result4,
     Result5,
     Result6,
     Result7,
     Result8,
     Result9,
     Result10,
     Result11,
     Result12,
     Result13,
     Result14,
     Result15,
     Result16,
     Result17,
     Result18,
     Result19,
     Result20,
     Result21,
     Result22,
     Result23,
     Result24,
     Result25,
     Result26,
     Result27,
     Result28,
     Result29,
     Result30,
     Result31,
     Result32,
     Result33,
     Result34,
     Result35,
     Result36,
     Result37,
     Result38,
     Result39,
     Result40,
     Result41,
     Result42,
     Result43,
     Result44,
     Result45,
     Result46,
     Result47,
     Result48,
     Result49,
     Result50,
     Result51,
     Result52,
     Result53,
     Result54,
     Result55,
     Result56,
     Result57,
     Result58,
     Result59,
     Result60,
     Result61,
     Result62,
     Result63,
     Result64,
     Result65,
     Result66,
     Result67,
     Result68,
     Result69,
     Result70,
     Result71,
     Result72,
     Result73,
     Result74,
     Result75,
     Result76,
     Result77,
     Result78,
     Result79,
     Result80,
     Result81,
     Result82,
     Result83,
     Result84,
     Result85,
     Result86,
     Result87,
     Result88,
     Result89,
     Result90,
     Result91,
     Result92,
     Result93,
     Result94,
     Result95,
     Result96,
--
+}
--
 impl<'a> ResultEndpoint {
     #[allow(unused_variables, clippy::useless_asref)]
     fn to_endpoint(
         &self,
         params: &'a Params,
         context: &ConditionContext<'a>,
     ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_http::endpoint::ResolveEndpointError> {
         match self {
             Self::Result0 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message("No endpoint rule matched")),
             Self::Result1 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Accelerate cannot be used with FIPS".to_string(),
             )),
             Self::Result2 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Cannot set dual-stack in combination with a custom endpoint.".to_string(),
             )),
             Self::Result3 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "A custom endpoint cannot be combined with FIPS".to_string(),
             )),
             Self::Result4 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "A custom endpoint cannot be combined with S3 Accelerate".to_string(),
             )),
             Self::Result5 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Partition does not support FIPS".to_string(),
             )),
             Self::Result6 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3Express does not support S3 Accelerate.".to_string(),
             )),
             Self::Result7 => {
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_auth = context
                     .s3_e_auth
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let uri_encoded_bucket = context
                     .uri_encoded_bucket
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.scheme());
                             out.push_str("://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.authority());
                             out.push('/');
                                         out.push_str(&bucket.as_ref());
                                         out.push_str(".op-");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&uri_encoded_bucket.as_ref());
                                         out.push_str(&outpost_id_ssa_2.as_ref());
                                         out.push_str(".s3-outposts.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.path());
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property("backend", "S3Express".to_string())
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), s3_e_auth.to_owned().into());
                                 out.insert("signingName".to_string(), "s3express".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
-+
+                                    )
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10690
+                                    )
                                     .build(),
-10692
+                            )
-10693
+                        }
             Self::Result8 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
 => {
                             let hardware_type = context.hardware_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Unrecognized hardware type: \"Expected hardware type o or e but got ");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&hardware_type.as_ref());
                                 out.push('"');
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let endpoint = params.endpoint.as_deref().unwrap_or_default();
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Custom endpoint `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&endpoint.as_ref());
                                 out.push_str("` was not a valid URI");
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 Accelerate cannot be used in this region".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_auth = context
                     .s3_e_auth
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.scheme());
                             out.push_str("://");
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                             out.push('.');
                                         out.push_str(".s3-fips.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.authority());
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.path());
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property("backend", "S3Express".to_string())
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), s3_e_auth.to_owned().into());
                                 out.insert("signingName".to_string(), "s3express".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10749
+                                    )
                                     .build(),
-10751
+                            )
-10752
+                        }
             Self::Result9 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3Express bucket name is not a valid virtual hostable name.".to_string(),
             )),
             Self::Result10 => {
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_ds = context
                     .s3_e_ds
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_fips = context
                     .s3_e_fips
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let uri_encoded_bucket = context
                     .uri_encoded_bucket
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://s3express-control");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&s3_e_fips.as_ref());
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&s3_e_ds.as_ref());
                             out.push('.');
                                         out.push_str(&bucket.as_ref());
                                         out.push_str(".s3-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                             out.push('/');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property("backend", "S3Express".to_string())
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3express".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10780
+                                    )
                                     .build(),
-10782
+                            )
-10783
+                        }
             Self::Result11 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_ds = context
                     .s3_e_ds
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_fips = context
                     .s3_e_fips
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_auth = context
                     .s3_e_auth
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3express_availability_zone_id = context
                     .s3express_availability_zone_id
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                             out.push_str(".s3express");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&s3_e_fips.as_ref());
                             out.push('-');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&s3express_availability_zone_id.as_ref());
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&s3_e_ds.as_ref());
                             out.push('.');
                                         out.push_str(".s3-accelerate.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property("backend", "S3Express".to_string())
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), s3_e_auth.to_owned().into());
                                 out.insert("signingName".to_string(), "s3express".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10811
+                                    )
                                     .build(),
-10813
+                            )
-10814
+                        }
             Self::Result12 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Unrecognized S3Express bucket name format.".to_string(),
             )),
             Self::Result13 => {
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_auth = context
                     .s3_e_auth
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.scheme());
                             out.push_str("://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.authority());
                                         out.push_str(&bucket.as_ref());
                                         out.push_str(".s3-accelerate.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.path());
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property("backend", "S3Express".to_string())
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), s3_e_auth.to_owned().into());
                                 out.insert("signingName".to_string(), "s3express".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10839
+                                    )
                                     .build(),
-10841
+                            )
-10842
+                        }
             Self::Result14 => {
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_ds = context
                     .s3_e_ds
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let s3_e_fips = context
                     .s3_e_fips
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://s3express-control");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&s3_e_fips.as_ref());
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&s3_e_ds.as_ref());
                             out.push('.');
                                         out.push_str(&bucket.as_ref());
                                         out.push_str(".s3.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property("backend", "S3Express".to_string())
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3express".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10870
+                                    )
                                     .build(),
-10872
+                            )
-10873
+                        }
             Self::Result15 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Expected a endpoint to be specified but no endpoint was found".to_string(),
             )),
             Self::Result16 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                             out.push_str(".ec2.");
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.normalized_path());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4a".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert(
                                         "signingRegionSet".to_string(),
                                         vec![::aws_smithy_types::Document::from("*".to_string())].into(),
                                     );
                                     out
                                 }),
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                     out
                                 }),
                             ],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10901
+                                    )
                                     .build(),
-10903
+                            )
-10904
+                        }
             Self::Result17 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                             out.push_str(".ec2.s3-outposts.");
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                                         out.push_str(&bucket.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                                         out.push_str(&url.authority());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.path());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4a".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert(
                                         "signingRegionSet".to_string(),
                                         vec![::aws_smithy_types::Document::from("*".to_string())].into(),
                                     );
                                     out
                                 }),
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                     out
                                 }),
                             ],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10933
+                                    )
                                     .build(),
-10935
+                            )
-10936
+                        }
             Self::Result18 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let outpost_id_ssa_2 = context
                     .outpost_id_ssa_2
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                             out.push_str(".op-");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&outpost_id_ssa_2.as_ref());
                             out.push('.');
                                         out.push_str(".s3-accelerate.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.authority());
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4a".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert(
                                         "signingRegionSet".to_string(),
                                         vec![::aws_smithy_types::Document::from("*".to_string())].into(),
                                     );
                                     out
                                 }),
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                     out
                                 }),
                             ],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10961
+                                    )
                                     .build(),
-10963
+                            )
-10964
+                        }
             Self::Result19 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let outpost_id_ssa_2 = context
                     .outpost_id_ssa_2
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                             out.push_str(".op-");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&outpost_id_ssa_2.as_ref());
                             out.push_str(".s3-outposts.");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                             out.push('.');
                                         out.push_str(".s3.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4a".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert(
                                         "signingRegionSet".to_string(),
                                         vec![::aws_smithy_types::Document::from("*".to_string())].into(),
                                     );
                                     out
                                 }),
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                     out
                                 }),
                             ],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-10989
+                                    )
                                     .build(),
-10991
+                            )
-10992
+                        }
             Self::Result20 => {
                 let hardware_type = context
                     .hardware_type
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Unrecognized hardware type: \"Expected hardware type o or e but got ");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&hardware_type.as_ref());
                     out.push('"');
                     out
                 }))
--
+            }
             Self::Result21 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
             )),
             Self::Result22 => {
                 let endpoint = params.endpoint.as_ref().map(|s| s.clone()).unwrap_or_default();
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Custom endpoint `");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&endpoint.as_ref());
                     out.push_str("` was not a valid URI");
                     out
                 }))
--
+            }
             Self::Result23 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3 Accelerate cannot be used in this region".to_string(),
             )),
             Self::Result24 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket.as_ref());
                             out.push_str(".s3-fips.dualstack.");
                                         out.push_str(".s3.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11020
+                                    )
                                     .build(),
-11022
+                            )
-11023
+                        }
             Self::Result25 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let effective_std_region = context
                     .effective_std_region
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid region: region was not a valid DNS name.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 Object Lambda does not support Dual-stack".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 Object Lambda does not support S3 Accelerate".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Access points are not supported for this operation".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Invalid configuration: region from ARN `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&bucket_arn.region());
                                 out.push_str("` does not match client region `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&region.as_ref());
                                 out.push_str("` and UseArnRegion is `false`");
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid ARN: Missing account id".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                             out.push_str(".s3-fips.");
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                                         out.push_str(&access_point_name_ssa_1.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_arn.account_id());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                                         out.push_str(&url.authority());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.path());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-object-lambda")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-11089
+                                    )
                                     .build(),
-11091
+                            )
-11092
+                        }
             Self::Result26 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let effective_std_region = context
                     .effective_std_region
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                             out.push_str(".s3-accelerate.dualstack.");
                                         out.push_str(&access_point_name_ssa_1.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                             out.push('.');
                                         out.push_str(&bucket_arn.account_id());
                                         out.push_str(".s3-object-lambda-fips.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                             out
                         })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
--
+                        )
                         .build(),
--
+                )
--
+            }
             Self::Result27 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             out.push_str("https://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                             out.push_str(".s3-accelerate.dualstack.");
                                         out.push_str(&effective_arn_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                                         out.push_str(&bucket_partition.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-object-lambda")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-11127
+                                    )
                                     .build(),
-11129
+                            )
-11130
+                        }
             Self::Result28 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let effective_std_region = context
                     .effective_std_region
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                             out.push_str(".s3.dualstack.");
                                         out.push_str(&access_point_name_ssa_1.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                                         out.push_str(&bucket_arn.account_id());
                                         out.push_str(".s3-object-lambda.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_arn_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                                         out.push_str(&bucket_partition.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-object-lambda")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-11165
+                                    )
                                     .build(),
-11167
+                            )
-11168
+                        }
             Self::Result29 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
 => {
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                                 #[allow(clippy::needless_borrow)]
                             out.push_str(&url.scheme());
                             out.push_str("://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.authority());
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.normalized_path());
                                 out.push_str(&access_point_name_ssa_1.as_ref());
                                 out.push('`');
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                                 #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                                 out.push_str(&bucket_arn.account_id());
                                 out.push('`');
                                 out
                         })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Invalid region in ARN: `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&bucket_arn.region());
                                 out.push_str("` (invalid DNS name)");
                                 out
                             })],
--
+                        )
                         .build(),
--
+                )
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-11204
+                        }
             Self::Result30 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Client was configured for partition `");
                                 #[allow(clippy::needless_borrow)]
                             out.push_str(&url.scheme());
                             out.push_str("://");
                                 out.push_str(&partition_result.name());
                                 out.push_str("` but ARN (`");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&bucket.as_ref());
                             out.push('.');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.authority());
                                 out.push_str("`) has `");
                                 #[allow(clippy::needless_borrow)]
                             out.push_str(&url.path());
                                 out.push_str(&bucket_partition.name());
                                 out.push('`');
                                 out
                         })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid ARN: bucket ARN is missing a region".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let arn_type = context.arn_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&arn_type.as_ref());
                                 out.push('`');
                                 out
                             })],
--
+                        )
                         .build(),
--
+                )
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-11243
+                        }
             Self::Result31 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let effective_std_region = context
                     .effective_std_region
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Access Points do not support S3 Accelerate".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                             out.push_str(".s3-accelerate.");
                                         out.push_str(&access_point_name_ssa_1.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                                         out.push_str(&bucket_arn.account_id());
                                         out.push_str(".s3-accesspoint-fips.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_arn_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_partition.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-11281
+                                    )
                                     .build(),
-11283
+                            )
-11284
+                        }
             Self::Result32 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let effective_std_region = context
                     .effective_std_region
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                             out.push_str(".s3.");
                                         out.push_str(&access_point_name_ssa_1.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                                         out.push_str(&bucket_arn.account_id());
                                         out.push_str(".s3-accesspoint-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_arn_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_partition.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-11319
+                                    )
                                     .build(),
-11321
+                            )
-11322
+                        }
             Self::Result33 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let effective_std_region = context
                     .effective_std_region
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket.as_ref());
                             out.push_str(".s3.");
                                         out.push_str(&access_point_name_ssa_1.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                                         out.push_str(&bucket_arn.account_id());
                                         out.push_str(".s3-accesspoint.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_arn_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                                         out.push_str(&bucket_partition.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-11357
+                                    )
                                     .build(),
-11359
+                            )
-11360
+                        }
             Self::Result34 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid region: region was not a valid DNS name.".to_string(),
             )),
             Self::Result35 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3 Object Lambda does not support Dual-stack".to_string(),
             )),
             Self::Result36 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3 Object Lambda does not support S3 Accelerate".to_string(),
             )),
             Self::Result37 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Access points are not supported for this operation".to_string(),
             )),
             Self::Result38 => {
                 let region = params.region.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Invalid configuration: region from ARN `");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&bucket_arn.region());
                     out.push_str("` does not match client region `");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&region.as_ref());
                     out.push_str("` and UseArnRegion is `false`");
                     out
                 }))
--
+            }
             Self::Result39 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid ARN: Missing account id".to_string(),
             )),
             Self::Result40 => {
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
 => {
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&access_point_name_ssa_1.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_arn.account_id());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.path());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-11396
+                                    )
                                     .build(),
-11398
+                            )
-11399
+                        }
             Self::Result41 => {
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_partition = context
                     .bucket_partition
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&access_point_name_ssa_1.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_arn.account_id());
                             out.push_str(".s3-object-lambda-fips.");
                                         out.push_str(".s3-accesspoint.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_arn_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_partition.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-11434
+                                    )
                                     .build(),
-11436
+                            )
-11437
+                        }
             Self::Result42 => {
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let effective_arn_region = context
                     .effective_arn_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Invalid ARN: The ARN was not for the S3 service, found: ");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&bucket_arn.service());
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 MRAP does not support dual-stack".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 MRAP does not support FIPS".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 MRAP does not support S3 Accelerate".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid configuration: Multi-Region Access Point ARNs are disabled.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let access_point_name_ssa_1 = context
                                 .access_point_name_ssa_1
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_partition = context
                     .bucket_partition
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&access_point_name_ssa_1.as_ref());
                             out.push('-');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_arn.account_id());
                             out.push_str(".s3-object-lambda.");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_arn_region.as_ref());
                             out.push('.');
                                         out.push_str(".accesspoint.s3-global.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_partition.dns_suffix());
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
-11483
+                                    )
                                     .build(),
-11485
+                            )
-11486
+                        }
             Self::Result43 => {
                 let access_point_name_ssa_1 = context
                     .access_point_name_ssa_1
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
 => {
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                     out.push_str("Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                                 out.push_str("Client was configured for partition `");
                                 #[allow(clippy::needless_borrow)]
                     out.push_str(&access_point_name_ssa_1.as_ref());
                                 out.push_str(&partition_result.name());
                                 out.push_str("` but bucket referred to partition `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&bucket_arn.partition());
                                 out.push('`');
                                 out
                 }))
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-11501
+                        }
             Self::Result44 => {
                 let bucket_arn = context
                     .bucket_arn
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid Access Point Name".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 Outposts does not support Dual-stack".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 Outposts does not support FIPS".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 Outposts does not support S3 Accelerate".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid Arn: Outpost Access Point ARN contains sub resources".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&bucket_arn.account_id());
                     out.push('`');
                     out
                 }))
--
+            }
             Self::Result45 => {
                 let bucket_arn = context
                     .bucket_arn
                             let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let access_point_name_ssa_2 = context
                                 .access_point_name_ssa_2
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Invalid region in ARN: `");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&bucket_arn.region());
                     out.push_str("` (invalid DNS name)");
                     out
                 }))
--
+            }
             Self::Result46 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_partition = context
                     .bucket_partition
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                     out.push_str("Client was configured for partition `");
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                     out.push_str(&partition_result.name());
                     out.push_str("` but ARN (`");
                                         out.push_str(&access_point_name_ssa_2.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                     out.push_str(&bucket.as_ref());
                     out.push_str("`) has `");
                                         out.push_str(&bucket_arn.account_id());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                     out.push_str(&bucket_partition.name());
                     out.push('`');
                     out
                 }))
--
+            }
             Self::Result47 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`.".to_string(),
             )),
             Self::Result48 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid ARN: bucket ARN is missing a region".to_string(),
             )),
             Self::Result49 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided".to_string(),
             )),
             Self::Result50 => {
                 let arn_type = context
                     .arn_type
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `");
                                         out.push_str(&outpost_id_ssa_1.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                     out.push_str(&arn_type.as_ref());
                     out.push('`');
                                         out.push_str(&url.authority());
                                         out
                 }))
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
-+
+                                    )
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-11561
+                        }
             Self::Result51 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Access Points do not support S3 Accelerate".to_string(),
             )),
             Self::Result52 => {
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
 => {
                             let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let effective_arn_region = context
                                 .effective_arn_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let access_point_name_ssa_1 = context
                     .access_point_name_ssa_1
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_partition = context
                     .bucket_partition
                             let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let access_point_name_ssa_2 = context
                                 .access_point_name_ssa_2
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&access_point_name_ssa_1.as_ref());
                                         out.push_str(&access_point_name_ssa_2.as_ref());
                                         out.push('-');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_arn.account_id());
                             out.push_str(".s3-accesspoint-fips.dualstack.");
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&outpost_id_ssa_1.as_ref());
                                         out.push_str(".s3-outposts.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_arn_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_partition.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
-+
+                                    )
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", effective_arn_region.as_ref()),
-11606
+                                    )
                                     .build(),
-11608
+                            )
-11609
+                        }
             Self::Result53 => {
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let effective_arn_region = context
                     .effective_arn_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let access_point_name_ssa_1 = context
                     .access_point_name_ssa_1
 => {
                             let outpost_type = context.outpost_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Expected an outpost type `accesspoint`, found ");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&outpost_type.as_ref());
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid ARN: expected an access point name".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid ARN: Expected a 4-component resource".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&outpost_id_ssa_1.as_ref());
                                 out.push('`');
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid ARN: The Outpost Id was not set".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             let arn_type = context.arn_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Invalid ARN: Unrecognized format: ");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&bucket.as_ref());
                                 out.push_str(" (type: ");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&arn_type.as_ref());
                                 out.push(')');
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid ARN: No ARN type specified".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let bucket = params.bucket.as_deref().unwrap_or_default();
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                 let mut out = String::new();
                                 out.push_str("Invalid ARN: `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&bucket.as_ref());
                                 out.push_str("` was not a valid ARN");
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Path-style addressing cannot be used with ARN buckets".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_partition = context
                     .bucket_partition
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let uri_encoded_bucket = context
                                 .uri_encoded_bucket
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&access_point_name_ssa_1.as_ref());
                             out.push('-');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_arn.account_id());
                             out.push_str(".s3-accesspoint-fips.");
                                         out.push_str("https://s3-fips.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_arn_region.as_ref());
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_partition.dns_suffix());
                                         out.push_str(&partition_result.dns_suffix());
                                         out.push('/');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11702
+                                    )
                                     .build(),
-11704
+                            )
-11705
+                        }
             Self::Result54 => {
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let effective_arn_region = context
                     .effective_arn_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let access_point_name_ssa_1 = context
                     .access_point_name_ssa_1
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_partition = context
                     .bucket_partition
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let uri_encoded_bucket = context
                                 .uri_encoded_bucket
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&access_point_name_ssa_1.as_ref());
                             out.push('-');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_arn.account_id());
                             out.push_str(".s3-accesspoint.dualstack.");
                                         out.push_str("https://s3-fips.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_arn_region.as_ref());
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_partition.dns_suffix());
                                         out.push_str(&partition_result.dns_suffix());
                                         out.push('/');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11736
+                                    )
                                     .build(),
-11738
+                            )
-11739
+                        }
             Self::Result55 => {
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let effective_arn_region = context
                     .effective_arn_region
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let access_point_name_ssa_1 = context
                     .access_point_name_ssa_1
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let uri_encoded_bucket = context
                                 .uri_encoded_bucket
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://s3.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.scheme());
                             out.push_str("://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&access_point_name_ssa_1.as_ref());
                             out.push('-');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_arn.account_id());
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.authority());
                                         out.push_str(&partition_result.dns_suffix());
                                         out.push('/');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.path());
                                         out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11770
+                                    )
                                     .build(),
-11772
+                            )
-11773
+                        }
             Self::Result56 => {
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let effective_arn_region = context
                     .effective_arn_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let access_point_name_ssa_1 = context
                     .access_point_name_ssa_1
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_partition = context
                     .bucket_partition
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let uri_encoded_bucket = context
                                 .uri_encoded_bucket
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&access_point_name_ssa_1.as_ref());
                             out.push('-');
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_arn.account_id());
                             out.push_str(".s3-accesspoint.");
                                         out.push_str(&url.authority());
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_arn_region.as_ref());
                             out.push('.');
                                         out.push_str(&url.normalized_path());
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_partition.dns_suffix());
                                         out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11804
+                                    )
                                     .build(),
-11806
+                            )
-11807
+                        }
             Self::Result57 => {
                 let bucket_arn = context
                     .bucket_arn
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let uri_encoded_bucket = context
                                 .uri_encoded_bucket
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                     out.push_str("Invalid ARN: The ARN was not for the S3 service, found: ");
                                         out.push_str("https://s3.");
                                         #[allow(clippy::needless_borrow)]
                     out.push_str(&bucket_arn.service());
                                         out.push_str(&partition_result.dns_suffix());
                                         out.push('/');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                 }))
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-11838
+                        }
             Self::Result58 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3 MRAP does not support dual-stack".to_string(),
             )),
             Self::Result59 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3 MRAP does not support FIPS".to_string(),
             )),
             Self::Result60 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3 MRAP does not support S3 Accelerate".to_string(),
             )),
             Self::Result61 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid configuration: Multi-Region Access Point ARNs are disabled.".to_string(),
             )),
             Self::Result62 => {
                 let partition_result = context
                     .partition_result
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 let access_point_name_ssa_1 = context
                     .access_point_name_ssa_1
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let uri_encoded_bucket = context
                                 .uri_encoded_bucket
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://");
                                         out.push_str("https://s3.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&access_point_name_ssa_1.as_ref());
                             out.push_str(".accesspoint.s3-global.");
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out.push('/');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4a".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert(
                                     "signingRegionSet".to_string(),
                                     vec![::aws_smithy_types::Document::from("*".to_string())].into(),
                                 );
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11869
+                                    )
                                     .build(),
-11871
+                            )
-11872
+                        }
             Self::Result63 => {
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_arn = context
                     .bucket_arn
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Path-style addressing cannot be used with S3 Accelerate".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                     out.push_str("Client was configured for partition `");
                                         #[allow(clippy::needless_borrow)]
                     out.push_str(&partition_result.name());
                     out.push_str("` but bucket referred to partition `");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&bucket_arn.partition());
                     out.push('`');
                     out
                 }))
--
+            }
             Self::Result64 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid Access Point Name".to_string(),
             )),
             Self::Result65 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3 Outposts does not support Dual-stack".to_string(),
             )),
             Self::Result66 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3 Outposts does not support FIPS".to_string(),
             )),
             Self::Result67 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "S3 Outposts does not support S3 Accelerate".to_string(),
             )),
             Self::Result68 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid Arn: Outpost Access Point ARN contains sub resources".to_string(),
             )),
             Self::Result69 => {
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let effective_arn_region = context
                     .effective_arn_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let outpost_id_ssa_1 = context
                     .outpost_id_ssa_1
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let access_point_name_ssa_2 = context
                     .access_point_name_ssa_2
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             out.push_str("https://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&access_point_name_ssa_2.as_ref());
                             out.push('-');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_arn.account_id());
                             out.push('.');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&outpost_id_ssa_1.as_ref());
                             out.push('.');
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                             out
                         })
                         .property(
                             "authSchemes",
                             vec![
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4a".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert(
                                         "signingRegionSet".to_string(),
                                         vec![::aws_smithy_types::Document::from("*".to_string())].into(),
                                     );
                                     out
                                 }),
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                     out
                                 }),
                             ],
--
+                        )
                         .build(),
--
+                )
--
+            }
             Self::Result70 => {
                 let bucket_arn = context
                     .bucket_arn
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let effective_arn_region = context
                     .effective_arn_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let bucket_partition = context
                     .bucket_partition
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let outpost_id_ssa_1 = context
                     .outpost_id_ssa_1
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let access_point_name_ssa_2 = context
                     .access_point_name_ssa_2
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             out.push_str("https://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&access_point_name_ssa_2.as_ref());
                             out.push('-');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_arn.account_id());
                             out.push('.');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&outpost_id_ssa_1.as_ref());
                             out.push_str(".s3-outposts.");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_arn_region.as_ref());
                             out.push('.');
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&bucket_partition.dns_suffix());
                                         out.push_str(&url.path());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4a".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert(
                                         "signingRegionSet".to_string(),
                                         vec![::aws_smithy_types::Document::from("*".to_string())].into(),
                                     );
                                     out
                                 }),
                                 ::aws_smithy_types::Document::from({
                                     let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                     out.insert("disableDoubleEncoding".to_string(), true.into());
                                     out.insert("name".to_string(), "sigv4".to_string().into());
                                     out.insert("signingName".to_string(), "s3-outposts".to_string().into());
                                     out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
                                     out
                                 }),
                             ],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-object-lambda")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11900
+                                    )
                                     .build(),
-11902
+                            )
-11903
+                        }
             Self::Result71 => {
                 let outpost_type = context
                     .outpost_type
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Expected an outpost type `accesspoint`, found ");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&outpost_type.as_ref());
                     out
                 }))
--
+            }
             Self::Result72 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid ARN: expected an access point name".to_string(),
             )),
             Self::Result73 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid ARN: Expected a 4-component resource".to_string(),
             )),
             Self::Result74 => {
                 let outpost_id_ssa_1 = context
                     .outpost_id_ssa_1
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&outpost_id_ssa_1.as_ref());
                     out.push('`');
                     out
                 }))
--
+            }
             Self::Result75 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid ARN: The Outpost Id was not set".to_string(),
             )),
             Self::Result76 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 let arn_type = context
                     .arn_type
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Invalid ARN: Unrecognized format: ");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&bucket.as_ref());
                     out.push_str(" (type: ");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&arn_type.as_ref());
                     out.push(')');
                     out
                 }))
--
+            }
             Self::Result77 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid ARN: No ARN type specified".to_string(),
             )),
             Self::Result78 => {
                 let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
                 ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                     let mut out = String::new();
                     out.push_str("Invalid ARN: `");
                     #[allow(clippy::needless_borrow)]
                     out.push_str(&bucket.as_ref());
                     out.push_str("` was not a valid ARN");
                     out
                 }))
--
+            }
             Self::Result79 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Path-style addressing cannot be used with ARN buckets".to_string(),
             )),
             Self::Result80 => {
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let uri_encoded_bucket = context
                     .uri_encoded_bucket
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://s3-fips.dualstack.");
                                         out.push_str("https://s3-object-lambda-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                             out.push('/');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-object-lambda")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11927
+                                    )
                                     .build(),
-11929
+                            )
-11930
+                        }
             Self::Result81 => {
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let uri_encoded_bucket = context
                     .uri_encoded_bucket
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://s3-fips.");
                                         out.push_str("https://s3-object-lambda.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                             out.push('/');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-object-lambda")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11954
+                                    )
                                     .build(),
-11956
+                            )
-11957
+                        }
             Self::Result82 => {
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let uri_encoded_bucket = context
                     .uri_encoded_bucket
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://s3.dualstack.");
                                         out.push_str("https://s3-fips.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                             out.push('/');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-11981
+                                    )
                                     .build(),
-11983
+                            )
-11984
+                        }
             Self::Result83 => {
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let uri_encoded_bucket = context
                     .uri_encoded_bucket
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         out.push_str("https://s3-fips.");
                                         #[allow(clippy::needless_borrow)]
                             out.push_str(&url.scheme());
                             out.push_str("://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.authority());
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.normalized_path());
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&uri_encoded_bucket.as_ref());
                             out
                         })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
--
+                        )
                         .build(),
--
+                )
--
+            }
             Self::Result84 => {
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let uri_encoded_bucket = context
                     .uri_encoded_bucket
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             out.push_str("https://s3.");
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                             out.push('/');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-12008
+                                    )
                                     .build(),
-12010
+                            )
-12011
+                        }
             Self::Result85 => {
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let uri_encoded_bucket = context
                     .uri_encoded_bucket
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://s3.");
                                         out.push_str("https://s3.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                             out.push('/');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&uri_encoded_bucket.as_ref());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-12035
+                                    )
                                     .build(),
-12037
+                            )
-12038
+                        }
             Self::Result86 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Path-style addressing cannot be used with S3 Accelerate".to_string(),
             )),
             Self::Result87 => {
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.scheme());
                                         out.push_str("://");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.path());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-12063
+                                    )
                                     .build(),
-12065
+                            )
-12066
+                        }
             Self::Result88 => {
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://s3-object-lambda-fips.");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                             out.push('.');
                                         out.push_str("https://s3.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-12087
+                                    )
                                     .build(),
-12089
+                            )
-12090
+                        }
             Self::Result89 => {
 => {
                             let effective_std_region = context
                                 .effective_std_region
                                 .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                                 .expect("Guaranteed to have a value by earlier checks.");
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(
                                 ::aws_smithy_types::endpoint::Endpoint::builder()
                                     .url({
                                         let mut out = String::new();
                             out.push_str("https://s3-object-lambda.");
                                         out.push_str("https://s3.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&effective_std_region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dns_suffix());
                                         out
                                     })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", effective_std_region.as_ref()),
-12114
+                                    )
                                     .build(),
-12116
+                            )
-12117
+                        }
             Self::Result90 => {
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             out.push_str("https://s3-fips.dualstack.");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                             out.push('.');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                             out
                         })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
--
+                        )
                         .build(),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "A region must be set when sending requests to S3.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
                         _ => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "No endpoint rule matched",
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
                     };
-+
+                }
 | -1 => {
                     return ::std::result::Result::Err(
                         Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("No endpoint rule matched"))
                             as ::aws_smithy_runtime_api::box_error::BoxError,
-+
+                    )
-+
+                }
                 ref_val => {
                     let is_complement = ref_val < 0;
                     let node = &NODES[(ref_val.unsigned_abs() as usize) - 1];
                     let condition_result = match node.condition_index {
 => region.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *effective_std_region = Some(
                                     crate::endpoint_lib::ite::ite!(
                                         (region) == &mut Some(("aws-global".into())),
                                         "us-east-1".to_string(),
                                         region.clone().expect("Reference already confirmed Some")
-+
+                                    )
                                     .into(),
                                 );
                                 true
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (accelerate) == (&true),
 => (use_fips) == (&true),
 => endpoint.is_some(),
 => (use_dual_stack) == (&true),
 => bucket.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--x-s3")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--xa-s3")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *partition_result = partition_resolver
                                     .resolve_partition(if let Some(param) = region { param } else { return false }, _diagnostic_collector)
                                     .map(|inner| inner.into());
                                 partition_result.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *url = crate::endpoint_lib::parse_url::parse_url(
                                     if let Some(param) = endpoint { param } else { return false },
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 url.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *access_point_suffix = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 access_point_suffix.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (access_point_suffix) == &mut Some(("--op-s3".into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *region_prefix = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 region_prefix.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *hardware_type = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 hardware_type.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *outpost_id_ssa_2 = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 outpost_id_ssa_2.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = partition_result {
                                 inner.name()
                             } else {
                                 return false;
                             }) == ("aws-cn")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *s3_e_ds = Some(crate::endpoint_lib::ite::ite!(use_dual_stack, ".dualstack".to_string(), "".to_string()).into());
                                 true
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *s3_e_fips = Some(crate::endpoint_lib::ite::ite!(use_fips, "-fips".to_string(), "".to_string()).into());
                                 true
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (force_path_style) == (&true),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *s3_e_auth = Some(
                                     crate::endpoint_lib::ite::ite!(
                                         crate::endpoint_lib::coalesce::coalesce!(*disable_s3_express_session_auth, false),
                                         "sigv4".to_string(),
                                         "sigv4-s3express".to_string()
-+
+                                    )
                                     .into(),
                                 );
                                 true
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
                                 if let Some(param) = bucket { param } else { return false },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *s3express_availability_zone_id = crate::endpoint_lib::split::split(
                                     if let Some(param) = bucket { param } else { return false },
                                     "--",
 ,
                                     _diagnostic_collector,
-+
+                                )
                                 .get(1)
                                 .cloned()
                                 .map(|inner| inner.into());
                                 s3express_availability_zone_id.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(param) = outpost_id_ssa_2 { param } else { return false },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(*use_s3_express_control_endpoint, false)) == (true)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (region_prefix) == &mut Some(("beta".into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
                                 if let Some(param) = bucket { param } else { return false },
                                 true,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = url { inner.scheme() } else { return false }) == ("http")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(param) = region { param } else { return false },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *bucket_arn = crate::endpoint_lib::arn::parse_arn(
                                     if let Some(param) = bucket { param } else { return false },
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 bucket_arn.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *effective_arn_region = Some(
                                     crate::endpoint_lib::ite::ite!(
                                         crate::endpoint_lib::coalesce::coalesce!(*use_arn_region, true),
                                         if let Some(inner) = bucket_arn { inner.region() } else { return false }.to_string(),
                                         region.clone().expect("Reference already confirmed Some")
-+
+                                    )
                                     .into(),
                                 );
                                 true
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = url { inner.is_ip() } else { return false }) == (true)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     false,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("arn:")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *uri_encoded_bucket = Some(
                                     crate::endpoint_lib::uri_encode::uri_encode(
                                         if let Some(param) = bucket { param } else { return false },
                                         _diagnostic_collector,
-+
+                                    )
                                     .into(),
                                 );
                                 true
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(*use_object_lambda_endpoint, false)) == (true)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *arn_type = if let Some(inner) = bucket_arn {
                                     inner.resource_id().first().cloned()
                                 } else {
                                     return false;
-+
+                                }
                                 .map(|inner| inner.into());
                                 arn_type.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (arn_type) == &mut Some(("".into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (arn_type) == &mut Some(("accesspoint".into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *access_point_name_ssa_1 = if let Some(inner) = bucket_arn {
                                     inner.resource_id().get(1).cloned()
                                 } else {
                                     return false;
-+
+                                }
                                 .map(|inner| inner.into());
                                 access_point_name_ssa_1.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (access_point_name_ssa_1) == &mut Some(("".into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-object-lambda")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(param) = region { param } else { return false },
                                 true,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = bucket_arn { inner.region() } else { return false }) == ("")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (hardware_type) == &mut Some(("e".into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = bucket { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 ""
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-outposts")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(*disable_access_points, false)) == (true)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *bucket_partition = partition_resolver
                                     .resolve_partition(
                                         if let Some(param) = effective_arn_region { param } else { return false },
                                         _diagnostic_collector,
-+
+                                    )
                                     .map(|inner| inner.into());
                                 bucket_partition.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (hardware_type) == &mut Some(("o".into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             if let Some(inner) = bucket_arn {
                                 inner.resource_id().get(4).cloned()
                             } else {
                                 return false;
-+
+                            }
                             .is_some()
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *outpost_id_ssa_1 = if let Some(inner) = bucket_arn {
                                     inner.resource_id().get(1).cloned()
                                 } else {
                                     return false;
-+
+                                }
                                 .map(|inner| inner.into());
                                 outpost_id_ssa_1.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(*use_arn_region, true)) == (true)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (effective_arn_region) == &mut Some((if let Some(inner) = bucket_arn { inner.region() } else { return false }.into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (region) == &mut Some(("aws-global".into()))
                         })(&mut _diagnostic_collector),
 => (use_global_endpoint) == (&true),
 => (disable_multi_region_access_points) == (&true),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (region) == &mut Some(("us-east-1".into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(param) = outpost_id_ssa_1 { param } else { return false },
                                 false,
                                 _diagnostic_collector,
-13810
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *outpost_type = if let Some(inner) = bucket_arn {
                                     inner.resource_id().get(2).cloned()
                                 } else {
                                     return false;
-13839
+                                }
             Self::Result91 => {
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             out.push_str("https://s3-fips.");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                             out.push('.');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                             out
                                 .map(|inner| inner.into());
                                 outpost_type.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = bucket_partition {
                                 inner.name()
                             } else {
                                 return false;
                             }) == (if let Some(inner) = partition_result {
                                 inner.name()
                             } else {
                                 return false;
                             })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(param) = effective_arn_region { param } else { return false },
                                 true,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = bucket_arn {
                                 inner.account_id()
                             } else {
                                 return false;
                             }) == ("")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(inner) = bucket_arn {
                                     inner.account_id()
                                 } else {
                                     return false;
                                 },
                                 false,
                                 _diagnostic_collector,
-13986
+                            )
                         .build(),
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(param) = access_point_name_ssa_1 {
                                     param
                                 } else {
                                     return false;
                                 },
                                 false,
                                 _diagnostic_collector,
-14018
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *access_point_name_ssa_2 = if let Some(inner) = bucket_arn {
                                     inner.resource_id().get(3).cloned()
                                 } else {
                                     return false;
-14047
+                                }
             Self::Result92 => {
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             out.push_str("https://s3.dualstack.");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                             out.push('.');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                             out
                         })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
--
+                        )
                         .build(),
--
+                )
                                 .map(|inner| inner.into());
                                 access_point_name_ssa_2.is_some()
-14050
+                            }
             Self::Result93 => {
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let url = context
                     .url
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.scheme());
                             out.push_str("://");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.authority());
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&url.path());
                             out
                         })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
--
+                        )
                         .build(),
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(param) = access_point_name_ssa_1 {
                                     param
                                 } else {
                                     return false;
                                 },
                                 true,
                                 _diagnostic_collector,
-14082
+                            )
--
+            }
             Self::Result94 => {
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             out.push_str("https://s3.");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                             out
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = bucket_arn { inner.partition() } else { return false })
                                 == (if let Some(inner) = partition_result {
                                     inner.name()
                                 } else {
                                     return false;
                                 })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
--
+                        )
                         .build(),
--
+                )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let effective_std_region = &mut context.effective_std_region;
                             let partition_result = &mut context.partition_result;
                             let url = &mut context.url;
                             let access_point_suffix = &mut context.access_point_suffix;
                             let region_prefix = &mut context.region_prefix;
                             let hardware_type = &mut context.hardware_type;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let s3_e_ds = &mut context.s3_e_ds;
                             let s3_e_fips = &mut context.s3_e_fips;
                             let s3_e_auth = &mut context.s3_e_auth;
                             let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                             let bucket_arn = &mut context.bucket_arn;
                             let effective_arn_region = &mut context.effective_arn_region;
                             let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                             let arn_type = &mut context.arn_type;
                             let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                             let bucket_partition = &mut context.bucket_partition;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let outpost_type = &mut context.outpost_type;
                             let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (outpost_type) == &mut Some(("accesspoint".into()))
                         })(&mut _diagnostic_collector),
                         _ => unreachable!("Invalid condition index"),
                     };
                     current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };
-14140
+                }
             Self::Result95 => {
                 let effective_std_region = context
                     .effective_std_region
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 let partition_result = context
                     .partition_result
                     .as_ref()
                     .map(|s| s.clone())
                     .expect("Guaranteed to have a value by earlier checks.");
                 ::std::result::Result::Ok(
                     ::aws_smithy_types::endpoint::Endpoint::builder()
                         .url({
                             let mut out = String::new();
                             out.push_str("https://s3.");
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&effective_std_region.as_ref());
                             out.push('.');
                             #[allow(clippy::needless_borrow)]
                             out.push_str(&partition_result.dns_suffix());
                             out
                         })
                         .property(
                             "authSchemes",
                             vec![::aws_smithy_types::Document::from({
                                 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                                 out.insert("disableDoubleEncoding".to_string(), true.into());
                                 out.insert("name".to_string(), "sigv4".to_string().into());
                                 out.insert("signingName".to_string(), "s3".to_string().into());
                                 out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
                                 out
                             })],
--
+                        )
                         .build(),
--
+                )
-14141
+            }
             Self::Result96 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "A region must be set when sending requests to S3.".to_string(),
             )),
-14142
+        }
-14143
+    }
-14144
+}
-14145
 const RESULTS: [ResultEndpoint; 97] = [
     ResultEndpoint::Result0,
     ResultEndpoint::Result1,
     ResultEndpoint::Result2,
     ResultEndpoint::Result3,
     ResultEndpoint::Result4,
     ResultEndpoint::Result5,
     ResultEndpoint::Result6,
     ResultEndpoint::Result7,
     ResultEndpoint::Result8,
     ResultEndpoint::Result9,
     ResultEndpoint::Result10,
     ResultEndpoint::Result11,
     ResultEndpoint::Result12,
     ResultEndpoint::Result13,
     ResultEndpoint::Result14,
     ResultEndpoint::Result15,
     ResultEndpoint::Result16,
     ResultEndpoint::Result17,
     ResultEndpoint::Result18,
     ResultEndpoint::Result19,
     ResultEndpoint::Result20,
     ResultEndpoint::Result21,
     ResultEndpoint::Result22,
     ResultEndpoint::Result23,
     ResultEndpoint::Result24,
     ResultEndpoint::Result25,
     ResultEndpoint::Result26,
     ResultEndpoint::Result27,
     ResultEndpoint::Result28,
     ResultEndpoint::Result29,
     ResultEndpoint::Result30,
     ResultEndpoint::Result31,
     ResultEndpoint::Result32,
     ResultEndpoint::Result33,
     ResultEndpoint::Result34,
     ResultEndpoint::Result35,
     ResultEndpoint::Result36,
     ResultEndpoint::Result37,
     ResultEndpoint::Result38,
     ResultEndpoint::Result39,
     ResultEndpoint::Result40,
     ResultEndpoint::Result41,
     ResultEndpoint::Result42,
     ResultEndpoint::Result43,
     ResultEndpoint::Result44,
     ResultEndpoint::Result45,
     ResultEndpoint::Result46,
     ResultEndpoint::Result47,
     ResultEndpoint::Result48,
     ResultEndpoint::Result49,
     ResultEndpoint::Result50,
     ResultEndpoint::Result51,
     ResultEndpoint::Result52,
     ResultEndpoint::Result53,
     ResultEndpoint::Result54,
     ResultEndpoint::Result55,
     ResultEndpoint::Result56,
     ResultEndpoint::Result57,
     ResultEndpoint::Result58,
     ResultEndpoint::Result59,
     ResultEndpoint::Result60,
     ResultEndpoint::Result61,
     ResultEndpoint::Result62,
     ResultEndpoint::Result63,
     ResultEndpoint::Result64,
     ResultEndpoint::Result65,
     ResultEndpoint::Result66,
     ResultEndpoint::Result67,
     ResultEndpoint::Result68,
     ResultEndpoint::Result69,
     ResultEndpoint::Result70,
     ResultEndpoint::Result71,
     ResultEndpoint::Result72,
     ResultEndpoint::Result73,
     ResultEndpoint::Result74,
     ResultEndpoint::Result75,
     ResultEndpoint::Result76,
     ResultEndpoint::Result77,
     ResultEndpoint::Result78,
     ResultEndpoint::Result79,
     ResultEndpoint::Result80,
     ResultEndpoint::Result81,
     ResultEndpoint::Result82,
     ResultEndpoint::Result83,
     ResultEndpoint::Result84,
     ResultEndpoint::Result85,
     ResultEndpoint::Result86,
     ResultEndpoint::Result87,
     ResultEndpoint::Result88,
     ResultEndpoint::Result89,
     ResultEndpoint::Result90,
     ResultEndpoint::Result91,
     ResultEndpoint::Result92,
     ResultEndpoint::Result93,
     ResultEndpoint::Result94,
     ResultEndpoint::Result95,
     ResultEndpoint::Result96,
 ];
 impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
     fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
         // Check single-entry cache
         if let Some((cached_params, cached_endpoint)) = &*self.endpoint_cache.lock().expect("endpoint cache lock poisoned") {
             if cached_params == params {
                 return ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(::std::result::Result::Ok(cached_endpoint.clone()));
-+
+            }
-+
+        }
         let result = self.resolve_endpoint(params);
         if let ::std::result::Result::Ok(ref endpoint) = result {
             *self.endpoint_cache.lock().expect("endpoint cache lock poisoned") = Some((params.clone(), endpoint.clone()));
-+
+        }
         ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(result)
-+
+    }
-+
+}
 const NODES: [crate::endpoint_lib::bdd_interpreter::BddNode; 521] = [
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: -1,
         high_ref: 1,
         low_ref: -1,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 5,
         high_ref: 100000002,
         low_ref: 100000004,

↧ Expand context

     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 55,
         high_ref: 100000015,
         low_ref: 100000020,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 46,
         high_ref: 100000015,
         low_ref: 3,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 55,
         high_ref: 100000019,
         low_ref: 100000020,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 46,
         high_ref: 100000017,
         low_ref: 5,

 path = "../aws-credential-types"
 version = "1.2.14"
-21
 [dependencies.aws-runtime]
 path = "../aws-runtime"
 version = "1.7.3"
-25
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.2.14"
-29
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 version = "0.63.6"
-33
 [dependencies.aws-smithy-json]
 path = "../aws-smithy-json"
 version = "0.62.5"
-37
 [dependencies.aws-smithy-observability]

 path = "../aws-smithy-observability"
 version = "0.2.6"
-41
 [dependencies.aws-smithy-query]
 path = "../aws-smithy-query"
 version = "0.60.15"
-45
 [dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client"]
 version = "1.10.3"
 version = "1.10.4"
-50
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-1x"]
 version = "1.11.6"
 version = "1.11.7"
-55
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x"]
 version = "1.4.7"
 version = "1.4.8"
-60
 [dependencies.aws-smithy-xml]
 path = "../aws-smithy-xml"
 version = "0.60.15"
-64
 [dependencies.aws-types]
 path = "../aws-types"
 version = "1.4.0"
-68
 [dependencies.fastrand]
 version = "2.0.0"
-71
 [dependencies.http]
 version = "0.2.9"
-74
 [dependencies.http-1x]
 version = "1"
 package = "http"
-78
 [dependencies.regex-lite]
 version = "0.1.5"
-81
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-87
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.2.14"
-92
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]
 version = "1.7.3"
-97
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.2.14"
-102
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.1.12"
-107
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.63.14"
-111
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.10.3"
 version = "1.10.4"
-116
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.11.6"
 version = "1.11.7"
-121
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.4.7"
 version = "1.4.8"
-126
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-131
 [dev-dependencies.proptest]
 version = "1"
-134
 [dev-dependencies.serde_json]

 version = "1.0.0"
-137
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
-141
 [dev-dependencies.tracing-subscriber]
 version = "0.3.16"
 features = ["env-filter", "json"]
-145
 [features]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 test-util = ["aws-credential-types/test-util", "aws-smithy-runtime/test-util"]
 gated-tests = []
 default = ["rustls", "default-https-client", "rt-tokio"]

     #[allow(unused_variables)]
     let endpoint = &_params.endpoint;
     #[allow(unused_variables)]
     let region = &_params.region;
     #[allow(unused_variables)]
     if let Some(endpoint) = endpoint {
         if (*use_fips) == (true) {
             return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid Configuration: FIPS and custom endpoint are not supported".to_string(),
             ));
-29
+        }
         if (*use_dual_stack) == (true) {
             return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                 "Invalid Configuration: Dualstack and custom endpoint are not supported".to_string(),
             ));
-34
+        }
         return Ok(::aws_smithy_types::endpoint::Endpoint::builder().url(endpoint.to_owned()).build());
-36
+    }
     #[allow(unused_variables)]
     if let Some(region) = region {

         )));
-417
+    }
     return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
         "Invalid Configuration: Missing Region".to_string(),
     ));
-421
+}

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/iam/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/iam/src/config/endpoint/internals.rs

tmp-codegen-diff/aws-sdk/sdk/iam/src/endpoint_lib/host.rs

tmp-codegen-diff/aws-sdk/sdk/kms/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/kms/src/endpoint_lib/host.rs

tmp-codegen-diff/aws-sdk/sdk/lambda/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/lambda/src/endpoint_lib/host.rs

tmp-codegen-diff/aws-sdk/sdk/polly/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/polly/src/endpoint_lib/host.rs

tmp-codegen-diff/aws-sdk/sdk/route53/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/route53/src/config/endpoint/internals.rs

tmp-codegen-diff/aws-sdk/sdk/route53/src/endpoint_lib/host.rs

tmp-codegen-diff/aws-sdk/sdk/s3/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/s3/src/config/endpoint.rs

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /*
  *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *  SPDX-License-Identifier: Apache-2.0
  */
-6
 use crate::endpoint_lib::diagnostic::DiagnosticCollector;
-8
 pub(crate) fn is_valid_host_label(label: &str, allow_dots: bool, e: &mut DiagnosticCollector) -> bool {
     let bytes = label.as_bytes();
     if allow_dots {
         for part in label.split('.') {
             if !is_valid_host_label(part, false, e) {
         let mut start = 0;
         for i in 0..bytes.len() {
             if bytes[i] == b'.' {
                 if !is_valid_segment(bytes, start, i, e) {
                     return false;
-17
+                }
                 start = i + 1;
-19
+            }
         true
-+
+        }
         is_valid_segment(bytes, start, bytes.len(), e)
     } else {
         if label.is_empty() || label.len() > 63 {
         is_valid_segment(bytes, 0, bytes.len(), e)
-+
+    }
-+
+}
-+
 #[inline]
 fn is_valid_segment(bytes: &[u8], start: usize, end: usize, e: &mut DiagnosticCollector) -> bool {
     let len = end - start;
     if len == 0 || len > 63 {
         e.report_error("host was too short or too long");
         return false;
-33
+    }
         label.chars().enumerate().all(|(idx, ch)| match (ch, idx) {
             ('-', 0) => {
     if bytes[start] == b'-' {
         e.report_error("cannot start with `-`");
                 false
         return false;
-37
+    }
             _ => ch.is_alphanumeric() || ch == '-',
         })
     for i in start..end {
         let b = bytes[i];
         if !b.is_ascii_alphanumeric() && b != b'-' {
             return false;
-42
+        }
-+
+    }
     true
-45
+}
-46
 #[cfg(all(test, feature = "gated-tests"))]
 mod test {
     use proptest::proptest;
-50
     fn is_valid_host_label(label: &str, allow_dots: bool) -> bool {
         super::is_valid_host_label(label, allow_dots, &mut DiagnosticCollector::new())
-53
+    }
-54
     #[allow(clippy::bool_assert_comparison)]
     #[test]
     fn basic_cases() {
         assert_eq!(is_valid_host_label("", false), false);
         assert_eq!(is_valid_host_label("", true), false);
         assert_eq!(is_valid_host_label(".", true), false);
         assert_eq!(is_valid_host_label("a.b", true), true);
         assert_eq!(is_valid_host_label("a.b", false), false);
         assert_eq!(is_valid_host_label("a.b.", true), false);
         assert_eq!(is_valid_host_label("a.b.c", true), true);
         assert_eq!(is_valid_host_label("a_b", true), false);
         assert_eq!(is_valid_host_label(&"a".repeat(64), false), false);
         assert_eq!(is_valid_host_label(&format!("{}.{}", "a".repeat(63), "a".repeat(63)), true), true);
-68
+    }
-69
     #[allow(clippy::bool_assert_comparison)]
     #[test]
     fn start_bounds() {
         assert_eq!(is_valid_host_label("-foo", false), false);
         assert_eq!(is_valid_host_label("-foo", true), false);
         assert_eq!(is_valid_host_label(".foo", true), false);
         assert_eq!(is_valid_host_label("a-b.foo", true), true);
-77
+    }
-78
     #[allow(clippy::bool_assert_comparison)]
     #[test]
     fn non_ascii_rejected() {
         // DNS host labels only allow ASCII alphanumeric and hyphens (RFC 952/1123)
         assert_eq!(is_valid_host_label("café", false), false);
         assert_eq!(is_valid_host_label("bücher", false), false);
         assert_eq!(is_valid_host_label("日本語", false), false);
         assert_eq!(is_valid_host_label("a.café.b", true), false);
         assert_eq!(is_valid_host_label("🚀rocket", false), false);
         // ASCII is fine
         assert_eq!(is_valid_host_label("abc123", false), true);
         assert_eq!(is_valid_host_label("a-b-c", false), true);
-+
+    }
-+
     use crate::endpoint_lib::diagnostic::DiagnosticCollector;
     use proptest::prelude::*;
     proptest! {
         #[test]
         fn no_panics(s in any::<String>(), dots in any::<bool>()) {
             is_valid_host_label(&s, dots);
-99
+        }
-100
+    }
-101
+}

 version = "1.4.3"
-30
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.2.14"
-34
 [dependencies.aws-smithy-checksums]
 path = "../aws-smithy-checksums"
 version = "0.64.7"
-38
 [dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 version = "0.60.20"
-42
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 features = ["event-stream"]
 version = "0.63.6"
-47
 [dependencies.aws-smithy-json]

 version = "7.5.2"
-185
 [dev-dependencies.http-body-util]
 version = "0.1.3"
-188
 [dev-dependencies.pin-project-lite]
 version = "0.2.14"
-191
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
-194
 [dev-dependencies.proptest]
 version = "1"
-197
 [dev-dependencies.serde_json]
 version = "1.0.0"
-200
 [dev-dependencies.smol]
 version = "1.2.0"
-203