AWS SDK

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

@@ -23,23 +843,717 @@

                 .store_append(::aws_runtime::sdk_feature::AwsSdkFeature::EndpointOverride);
-24
+        }
         ::std::result::Result::Ok(())
-26
+    }
-27
+}
-28
 #[cfg(test)]
 mod test {
-31
     /// Vanilla outposts without ARN region + access point ARN@us-west-2
     #[test]
     fn test_1() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-west-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-58
+                )
                 .build()
         );
-61
+    }
-62
     /// Vanilla outposts with ARN region + access point ARN@us-west-2
     #[test]
     fn test_2() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-89
+                )
                 .build()
         );
-92
+    }
-93
     /// accept an access point ARN@us-west-2
     #[test]
     fn test_3() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-west-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-120
+                )
                 .build()
         );
-123
+    }
-124
     /// vanilla outposts china@cn-north-1
     #[test]
     fn test_4() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("cn-north-1".to_string())
             .requires_account_id(true)
             .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-outposts.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.cn-north-1.amazonaws.com.cn")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-151
+                )
                 .build()
         );
-154
+    }
-155
     /// gov region@us-west-2
     #[test]
     fn test_5() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-west-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-182
+                )
                 .build()
         );
-185
+    }
-186
     /// gov cloud with fips@us-west-2
     #[test]
     fn test_6() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-west-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-213
+                )
                 .build()
         );
-216
+    }
-217
     /// govcloud with fips + arn region@us-gov-west-1
     #[test]
     fn test_7() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name(
                 "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string(),
-224
+            )
             .account_id("123456789012".to_string())
             .region("us-gov-west-1".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-gov-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "us-gov-east-1".to_string())
-246
+                )
                 .build()
         );
-249
+    }
-250
     /// gov region@cn-north-1
     #[test]
     fn test_8() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("cn-north-1".to_string())
             .requires_account_id(true)
             .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-outposts.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.cn-north-1.amazonaws.com.cn")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-277
+                )
                 .build()
         );
-280
+    }
-281
     /// gov cloud with fips@cn-north-1
     #[test]
     fn test_9() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("cn-north-1".to_string())
             .requires_account_id(true)
             .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 [gov cloud with fips@cn-north-1]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-298
+    }
-299
     /// govcloud with fips + arn region@us-gov-west-1
     #[test]
     fn test_10() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name(
                 "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string(),
-306
+            )
             .account_id("123456789012".to_string())
             .region("us-gov-west-1".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-gov-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "us-gov-east-1".to_string())
-328
+                )
                 .build()
         );
-331
+    }
-332
     /// gov region@af-south-1
     #[test]
     fn test_11() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("af-south-1".to_string())
             .requires_account_id(true)
             .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-outposts.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.af-south-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-359
+                )
                 .build()
         );
-362
+    }
-363
     /// gov cloud with fips@af-south-1
     #[test]
     fn test_12() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("af-south-1".to_string())
             .requires_account_id(true)
             .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-outposts-fips.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.af-south-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-390
+                )
                 .build()
         );
-393
+    }
-394
     /// govcloud with fips + arn region@us-gov-west-1
     #[test]
     fn test_13() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name(
                 "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string(),
-401
+            )
             .account_id("123456789012".to_string())
             .region("us-gov-west-1".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-gov-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "us-gov-east-1".to_string())
-423
+                )
                 .build()
         );
-426
+    }
-427
     /// CreateBucket + OutpostId = outposts endpoint@us-east-2
     #[test]
     fn test_14() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("blah".to_string())
             .outpost_id("123".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(false)
             .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-outposts.us-east-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-east-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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-452
+                )
                 .build()
         );
-455
+    }
-456
     /// CreateBucket + OutpostId with fips = outposts endpoint@us-east-2
     #[test]
     fn test_15() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("blah".to_string())
             .outpost_id("123".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(false)
             .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-outposts-fips.us-east-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-east-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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-481
+                )
                 .build()
         );
-484
+    }
-485
     /// CreateBucket without OutpostId = regular endpoint@us-east-2
     #[test]
     fn test_16() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("blah".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(false)
             .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-control.us-east-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-control.us-east-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-east-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-east-2".to_string())
-509
+                )
                 .build()
         );
-512
+    }
-513
     /// ListRegionalBuckets + OutpostId = outposts endpoint@us-east-2
     #[test]
     fn test_17() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .outpost_id("op-123".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-east-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-east-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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-538
+                )
                 .build()
         );
-541
+    }
-542
     /// ListRegionalBuckets without OutpostId = regular endpoint@us-east-2
     #[test]
     fn test_18() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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://123456789012.s3-control.us-east-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://123456789012.s3-control.us-east-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-east-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-east-2".to_string())
-566
+                )
                 .build()
         );
-569
+    }
-570
     /// ListRegionalBucket + OutpostId with fips = outposts endpoint@us-east-2
     #[test]
     fn test_19() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .outpost_id("op-123".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-east-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-east-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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-595
+                )
                 .build()
         );
-598
+    }
-599
     /// outpost access points support dualstack@us-west-2
     #[test]
     fn test_20() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-west-2.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-west-2.api.aws")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-626
+                )
                 .build()
         );
-629
+    }
-630
     /// outpost access points support dualstack@af-south-1
     #[test]
     fn test_21() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("af-south-1".to_string())
             .requires_account_id(true)
             .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-outposts.af-south-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.af-south-1.api.aws")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-657
+                )
                 .build()
         );
-660
+    }
-661
     /// outpost access points support fips + dualstack@af-south-1
     #[test]
     fn test_22() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("af-south-1".to_string())
             .requires_account_id(true)
             .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://s3-outposts-fips.af-south-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.af-south-1.api.aws")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-688
+                )
                 .build()
         );
-691
+    }
-692
     /// invalid ARN: must be include outpost ID@us-west-2
     #[test]
     fn test_23() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost".to_string())

↧ Expand context

             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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 ARN: The Outpost Id was not set [invalid ARN: must be include outpost ID@us-west-2]");
         assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
-710
+    }
-711
     /// invalid ARN: must specify access point@us-west-2
     #[test]
     fn test_24() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456".to_string())
             .region("us-west-2".to_string())

@@ -862,736 +1066,916 @@

↥ Expand context

             .requires_account_id(true)
             .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 ARN: Expected a 4-component resource [invalid ARN@us-west-2]");
         assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
-745
+    }
-746
     /// when set, AccountId drives AP construction@us-west-2
     #[test]
     fn test_26() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("myaccesspoint".to_string())
             .account_id("myid-1234".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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://myid-1234.s3-control.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://myid-1234.s3-control.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())
-771
+                )
                 .build()
         );
-774
+    }
-775
     /// Account ID set inline and in ARN but they both match@us-west-2
     #[test]
     fn test_27() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .use_arn_region(false)
             .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-outposts.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-west-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-803
+                )
                 .build()
         );
-806
+    }
-807
     /// Account ID set inline and in ARN and they do not match@us-west-2
     #[test]
     fn test_28() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("999999999999".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .use_arn_region(false)
             .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 ARN: the accountId specified in the ARN (`123456789012`) does not match the parameter (`999999999999`) [Account ID set inline and in ARN and they do not match@us-west-2]");
         assert_eq!(
             format!("{}", error),
             "Invalid ARN: the accountId specified in the ARN (`123456789012`) does not match the parameter (`999999999999`)"
-827
+        )
-828
+    }
-829
     /// get access point prefixed with account id using endpoint url@us-west-2
     #[test]
     fn test_29() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("apname".to_string())
             .account_id("123456789012".to_string())
             .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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://123456789012.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://123456789012.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())
-855
+                )
                 .build()
         );
-858
+    }
-859
     /// endpoint url with s3-outposts@us-west-2
     #[test]
     fn test_30() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .endpoint("https://beta.example.com".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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://beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://beta.example.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-887
+                )
                 .build()
         );
-890
+    }
-891
     /// access point name with a bucket arn@us-west-2
     #[test]
     fn test_31() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())

↧ Expand context

             .endpoint("beta.example.com".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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: Expected an outpost type `accesspoint`, found `bucket` [access point name with a bucket arn@us-west-2]");
         assert_eq!(format!("{}", error), "Expected an outpost type `accesspoint`, found `bucket`")
-909
+    }
-910
     /// bucket arn with access point name@us-west-2
     #[test]
     fn test_32() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .endpoint("beta.example.com".to_string())

@@ -1074,924 +1957,1669 @@

↥ Expand context

         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err(
             "expected error: Invalid ARN: Expected an outpost type `bucket`, found `accesspoint` [bucket arn with access point name@us-west-2]",
         );
         assert_eq!(
             format!("{}", error),
             "Invalid ARN: Expected an outpost type `bucket`, found `accesspoint`"
-931
+        )
-932
+    }
-933
     /// create bucket with outposts@us-west-2
     #[test]
     fn test_33() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("bucketname".to_string())
             .endpoint("https://beta.example.com".to_string())
             .outpost_id("op-123".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(false)
             .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://beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-959
+                )
                 .build()
         );
-962
+    }
-963
     /// get bucket with endpoint_url@us-west-2
     #[test]
     fn test_34() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .endpoint("https://beta.example.com".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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://beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://beta.example.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-990
+                )
                 .build()
         );
-993
+    }
-994
     /// ListRegionalBucket + OutpostId endpoint url@us-east-2
     #[test]
     fn test_35() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .endpoint("https://beta.example.com".to_string())
             .outpost_id("op-123".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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://beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-1020
+                )
                 .build()
         );
-1023
+    }
-1024
     /// ListRegionalBucket + OutpostId + fips + endpoint url@us-east-2
     #[test]
     fn test_36() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .endpoint("https://beta.example.com".to_string())
             .outpost_id("op-123".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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://beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-1050
+                )
                 .build()
         );
-1053
+    }
-1054
     /// ListRegionalBucket + OutpostId + fips + dualstack@us-east-2
     #[test]
     fn test_37() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .outpost_id("op-123".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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://s3-outposts-fips.us-east-2.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-east-2.api.aws")
                 .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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-1079
+                )
                 .build()
         );
-1082
+    }
-1083
     /// CreateBucket + OutpostId endpoint url@us-east-2
     #[test]
     fn test_38() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("blah".to_string())
             .endpoint("https://beta.example.com".to_string())
             .outpost_id("123".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(false)
             .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://beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-1109
+                )
                 .build()
         );
-1112
+    }
-1113
     /// dualstack cannot be used with outposts when an endpoint URL is set@us-west-2.
     #[test]
     fn test_39() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .endpoint("https://s3-outposts.us-west-2.api.aws".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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: Invalid Configuration: DualStack and custom endpoint are not supported [dualstack cannot be used with outposts when an endpoint URL is set@us-west-2.]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: DualStack and custom endpoint are not supported"
-1132
+        )
-1133
+    }
-1134
     /// vanilla bucket arn requires account id@us-west-2
     #[test]
     fn test_40() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-west-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-1160
+                )
                 .build()
         );
-1163
+    }
-1164
     /// bucket arn with UseArnRegion = true (arn region supercedes client configured region)@us-west-2
     #[test]
     fn test_41() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1190
+                )
                 .build()
         );
-1193
+    }
-1194
     /// bucket ARN in gov partition (non-fips)@us-gov-east-1
     #[test]
     fn test_42() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-gov-east-1".to_string())
             .requires_account_id(true)
             .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-outposts.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-gov-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "us-gov-east-1".to_string())
-1220
+                )
                 .build()
         );
-1223
+    }
-1224
     /// bucket ARN in gov partition with FIPS@us-gov-west-1
     #[test]
     fn test_43() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws-us-gov:s3-outposts:us-gov-west-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-gov-west-1".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-gov-west-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-gov-west-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-gov-west-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-outposts".to_string())
                         .put("signingRegion", "us-gov-west-1".to_string())
-1250
+                )
                 .build()
         );
-1253
+    }
-1254
     /// bucket ARN in aws partition with FIPS@us-east-2
     #[test]
     fn test_44() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-east-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-east-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-1280
+                )
                 .build()
         );
-1283
+    }
-1284
     /// bucket ARN in aws partition with fips + dualstack@us-east-2
     #[test]
     fn test_45() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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://s3-outposts-fips.us-east-2.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-east-2.api.aws")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-1310
+                )
                 .build()
         );
-1313
+    }
-1314
     /// vanilla bucket arn requires account id@cn-north-1
     #[test]
     fn test_46() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("cn-north-1".to_string())
             .requires_account_id(true)
             .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-outposts.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.cn-north-1.amazonaws.com.cn")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "cn-north-1".to_string())
-1340
+                )
                 .build()
         );
-1343
+    }
-1344
     /// bucket arn with UseArnRegion = true (arn region supercedes client configured region)@us-west-2
     #[test]
     fn test_47() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1370
+                )
                 .build()
         );
-1373
+    }
-1374
     /// bucket ARN in gov partition (non-fips)@us-gov-east-1
     #[test]
     fn test_48() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-gov-east-1".to_string())
             .requires_account_id(true)
             .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-outposts.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-gov-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "us-gov-east-1".to_string())
-1400
+                )
                 .build()
         );
-1403
+    }
-1404
     /// bucket ARN in gov partition with FIPS@us-gov-west-1
     #[test]
     fn test_49() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws-us-gov:s3-outposts:us-gov-west-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-gov-west-1".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-gov-west-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-gov-west-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-gov-west-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-outposts".to_string())
                         .put("signingRegion", "us-gov-west-1".to_string())
-1430
+                )
                 .build()
         );
-1433
+    }
-1434
     /// bucket ARN in aws partition with FIPS@us-east-2
     #[test]
     fn test_50() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-east-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-east-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-1460
+                )
                 .build()
         );
-1463
+    }
-1464
     /// Outposts support dualstack @us-west-2
     #[test]
     fn test_51() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-west-2.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-west-2.api.aws")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-1490
+                )
                 .build()
         );
-1493
+    }
-1494
     /// vanilla bucket arn requires account id@af-south-1
     #[test]
     fn test_52() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("af-south-1".to_string())
             .requires_account_id(true)
             .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-outposts.af-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.af-south-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "af-south-1".to_string())
-1520
+                )
                 .build()
         );
-1523
+    }
-1524
     /// bucket arn with UseArnRegion = true (arn region supercedes client configured region)@us-west-2
     #[test]
     fn test_53() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-1550
+                )
                 .build()
         );
-1553
+    }
-1554
     /// bucket ARN in gov partition (non-fips)@us-gov-east-1
     #[test]
     fn test_54() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-gov-east-1".to_string())
             .requires_account_id(true)
             .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-outposts.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-gov-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".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-outposts".to_string())
                         .put("signingRegion", "us-gov-east-1".to_string())
-1580
+                )
                 .build()
         );
-1583
+    }
-1584
     /// bucket ARN in gov partition with FIPS@us-gov-west-1
     #[test]
     fn test_55() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws-us-gov:s3-outposts:us-gov-west-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-gov-west-1".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-gov-west-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-gov-west-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-gov-west-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-outposts".to_string())
                         .put("signingRegion", "us-gov-west-1".to_string())
-1610
+                )
                 .build()
         );
-1613
+    }
-1614
     /// bucket ARN in aws partition with FIPS@us-east-2
     #[test]
     fn test_56() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-east-2".to_string())
             .requires_account_id(true)
             .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-outposts-fips.us-east-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts-fips.us-east-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-outposts".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-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-outposts".to_string())
                         .put("signingRegion", "us-east-2".to_string())
-1640
+                )
                 .build()
         );
-1643
+    }
-1644
     /// Invalid ARN: missing outpost id and bucket@us-west-2
     #[test]
     fn test_57() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost".to_string())

↧ Expand context

             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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 ARN: The Outpost Id was not set [Invalid ARN: missing outpost id and bucket@us-west-2]");
         assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
-1661
+    }
-1662
     /// Invalid ARN: missing bucket@us-west-2
     #[test]
     fn test_58() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)

@@ -1991,1703 +2484,2118 @@

↥ Expand context

             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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 ARN: expected a bucket name [Invalid ARN: missing bucket id@us-west-2]");
         assert_eq!(format!("{}", error), "Invalid ARN: expected a bucket name")
-1713
+    }
-1714
     /// account id inserted into hostname@us-west-2
     #[test]
     fn test_61() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("1234567890".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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://1234567890.s3-control.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://1234567890.s3-control.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())
-1738
+                )
                 .build()
         );
-1741
+    }
-1742
     /// account id prefix with dualstack@us-east-1
     #[test]
     fn test_62() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("1234567890".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://1234567890.s3-control.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://1234567890.s3-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(), "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())
-1766
+                )
                 .build()
         );
-1769
+    }
-1770
     /// account id prefix with fips@us-east-1
     #[test]
     fn test_63() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("1234567890".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://1234567890.s3-control-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://1234567890.s3-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(), "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())
-1794
+                )
                 .build()
         );
-1797
+    }
-1798
     /// custom account id prefix with fips@us-east-1
     #[test]
     fn test_64() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://123456789012.s3-control-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://123456789012.s3-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(), "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())
-1822
+                )
                 .build()
         );
-1825
+    }
-1826
     /// standard url @ us-east-1
     #[test]
     fn test_65() {
         let params = crate::config::endpoint::Params::builder()
             .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-control.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-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(), "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())
-1846
+                )
                 .build()
         );
-1849
+    }
-1850
     /// fips url @ us-east-1
     #[test]
     fn test_66() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".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-control-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-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(), "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())
-1871
+                )
                 .build()
         );
-1874
+    }
-1875
     /// dualstack url @ us-east-1
     #[test]
     fn test_67() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .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-control.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-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(), "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())
-1896
+                )
                 .build()
         );
-1899
+    }
-1900
     /// fips,dualstack url @ us-east-1
     #[test]
     fn test_68() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-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://s3-control-fips.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-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(), "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())
-1922
+                )
                 .build()
         );
-1925
+    }
-1926
     /// standard url @ cn-north-1
     #[test]
     fn test_69() {
         let params = crate::config::endpoint::Params::builder()
             .region("cn-north-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-control.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-control.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())
-1946
+                )
                 .build()
         );
-1949
+    }
-1950
     /// fips @ cn-north-1
     #[test]
     fn test_70() {
         let params = crate::config::endpoint::Params::builder()
             .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 [fips @ cn-north-1]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-1964
+    }
-1965
     /// custom account id prefix @us-east-1
     #[test]
     fn test_71() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://123456789012.s3-control.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://123456789012.s3-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(), "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())
-1989
+                )
                 .build()
         );
-1992
+    }
-1993
     /// invalid account id prefix @us-east-1
     #[test]
     fn test_72() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("/?invalid&not-host*label".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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: AccountId must only contain a-z, A-Z, 0-9 and `-`. [invalid account id prefix @us-east-1]");
         assert_eq!(format!("{}", error), "AccountId must only contain a-z, A-Z, 0-9 and `-`.")
-2009
+    }
-2010
     /// custom account id prefix with fips@us-east-1
     #[test]
     fn test_73() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://123456789012.s3-control-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://123456789012.s3-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(), "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())
-2034
+                )
                 .build()
         );
-2037
+    }
-2038
     /// custom account id prefix with dualstack,fips@us-east-1
     #[test]
     fn test_74() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://123456789012.s3-control-fips.dualstack.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://123456789012.s3-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(), "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())
-2062
+                )
                 .build()
         );
-2065
+    }
-2066
     /// custom account id with custom endpoint
     #[test]
     fn test_75() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .endpoint("https://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: https://123456789012.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://123456789012.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())
-2089
+                )
                 .build()
         );
-2092
+    }
-2093
     /// RequiresAccountId with AccountId unset
     #[test]
     fn test_76() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())

↧ Expand context

             .requires_account_id(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: AccountId is required but not set [RequiresAccountId with AccountId unset]");
         assert_eq!(format!("{}", error), "AccountId is required but not set")
-2106
+    }
-2107
     /// RequiresAccountId with AccountId unset and custom endpoint
     #[test]
     fn test_77() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .endpoint("https://beta.example.com".to_string())
             .requires_account_id(true)
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);

@@ -2496,2130 +2630,2246 @@

↥ Expand context

             .account_id("/?invalid&not-host*label".to_string())
             .requires_account_id(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: AccountId must only contain a-z, A-Z, 0-9 and `-`. [RequiresAccountId with invalid AccountId and custom endpoint]",
         );
         assert_eq!(format!("{}", error), "AccountId must only contain a-z, A-Z, 0-9 and `-`.")
-2140
+    }
-2141
     /// account id with custom endpoint, fips
     #[test]
     fn test_79() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("123456789012".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .endpoint("https://example.com".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://123456789012.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://123456789012.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())
-2165
+                )
                 .build()
         );
-2168
+    }
-2169
     /// custom endpoint, fips
     #[test]
     fn test_80() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .endpoint("https://example.com".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://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())
-2191
+                )
                 .build()
         );
-2194
+    }
-2195
     /// custom endpoint, fips
     #[test]
     fn test_81() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())
             .endpoint("https://example.com".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://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())
-2217
+                )
                 .build()
         );
-2220
+    }
-2221
     /// custom endpoint, DualStack
     #[test]
     fn test_82() {
         let params = crate::config::endpoint::Params::builder()
             .region("us-east-1".to_string())

↧ Expand context

             .endpoint("https://example.com".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: Invalid Configuration: DualStack and custom endpoint are not supported [custom endpoint, DualStack]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: DualStack and custom endpoint are not supported"
-2239
+        )
-2240
+    }
-2241
     /// region not set
     #[test]
     fn test_83() {
         let params = crate::config::endpoint::Params::builder().build().expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();

@@ -2727,2343 +2834,2438 @@

↥ 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: Invalid ARN: missing account ID [bucket ARN with missing accountId]");
         assert_eq!(format!("{}", error), "Invalid ARN: missing account ID")
-2351
+    }
-2352
     /// endpoint url with accesspoint (non-arn)
     #[test]
     fn test_90() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("apname".to_string())
             .endpoint("https://beta.example.com".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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://123456789012.beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://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())
-2378
+                )
                 .build()
         );
-2381
+    }
-2382
     /// access point name with an accesspoint arn@us-west-2
     #[test]
     fn test_91() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .endpoint("https://beta.example.com".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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://beta.example.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://beta.example.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2409
+                )
                 .build()
         );
-2412
+    }
-2413
     /// DualStack + Custom endpoint is not supported(non-arn)
     #[test]
     fn test_92() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("apname".to_string())

↧ Expand context

             .endpoint("https://beta.example.com".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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: Invalid Configuration: DualStack and custom endpoint are not supported [DualStack + Custom endpoint is not supported(non-arn)]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: DualStack and custom endpoint are not supported"
-2433
+        )
-2434
+    }
-2435
     /// get bucket with custom endpoint and dualstack is not supported@us-west-2
     #[test]
     fn test_93() {

@@ -2916,2520 +2986,2584 @@

↥ Expand context

             .region("invalid-region 42".to_string())
             .account_id("0123456".to_string())
             .requires_account_id(true)
             .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. [OutpostId with invalid region]");
         assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
-2531
+    }
-2532
     /// OutpostId with RequireAccountId unset
     #[test]
     fn test_98() {
         let params = crate::config::endpoint::Params::builder()
             .outpost_id("op-123".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-outposts.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://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(), "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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2555
+                )
                 .build()
         );
-2558
+    }
-2559
     /// Outpost Accesspoint ARN with arn region and client region mismatch with UseArnRegion=false
     #[test]
     fn test_99() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())

↧ Expand context

             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .use_arn_region(false)
             .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` [Outpost Accesspoint ARN with arn region and client region mismatch with 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`"
-2579
+        )
-2580
+    }
-2581
     /// Outpost Bucket ARN with arn region and client region mismatch with UseArnRegion=false
     #[test]
     fn test_100() {

@@ -2997,2595 +3103,2689 @@

↥ 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` [Outpost Bucket ARN with arn region and client region mismatch with 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`"
-2601
+        )
-2602
+    }
-2603
     /// Accesspoint ARN with region mismatch and UseArnRegion unset
     #[test]
     fn test_101() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2630
+                )
                 .build()
         );
-2633
+    }
-2634
     /// Bucket ARN with region mismatch and UseArnRegion unset
     #[test]
     fn test_102() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-east-1.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2660
+                )
                 .build()
         );
-2663
+    }
-2664
     /// Outpost Bucket ARN with partition mismatch with UseArnRegion=true
     #[test]
     fn test_103() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())

↧ Expand context

             .region("us-west-2".to_string())
             .requires_account_id(true)
             .use_arn_region(true)
             .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 has `aws-cn` [Outpost Bucket ARN with partition mismatch with UseArnRegion=true]");
         assert_eq!(format!("{}", error), "Client was configured for partition `aws` but ARN has `aws-cn`")
-2681
+    }
-2682
     /// Accesspoint ARN with partition mismatch and UseArnRegion=true
     #[test]
     fn test_104() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
             .account_id("123456789012".to_string())
             .region("us-west-2".to_string())

@@ -3128,2714 +3938,3410 @@

↥ 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: region from ARN `cn-north-1` does not match client region `us-west-2` and UseArnRegion is `false` [Accesspoint ARN with region mismatch, UseArnRegion=false and custom endpoint]");
         assert_eq!(
             format!("{}", error),
             "Invalid configuration: region from ARN `cn-north-1` does not match client region `us-west-2` and UseArnRegion is `false`"
-2721
+        )
-2722
+    }
-2723
     /// outpost bucket arn@us-west-2
     #[test]
     fn test_106() {
         let params = crate::config::endpoint::Params::builder()
             .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
             .region("us-west-2".to_string())
             .requires_account_id(true)
             .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-outposts.us-west-2.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3-outposts.us-west-2.amazonaws.com")
                 .header("x-amz-account-id", "123456789012")
                 .header("x-amz-outpost-id", "op-01234567890123456")
                 .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-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("sigv4", 3)
                         .put("disableDoubleEncoding", true)
                         .put("signingName", "s3-outposts".to_string())
                         .put("signingRegion", "us-west-2".to_string())
-2749
+                )
                 .build()
         );
-2752
+    }
-2753
     /// S3 Snow Control with bucket
     #[test]
     fn test_107() {
         let params = crate::config::endpoint::Params::builder()
             .region("snow".to_string())
             .bucket("bucketName".to_string())
             .endpoint("https://10.0.1.12:433".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://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())
-2777
+                )
                 .build()
         );
-2780
+    }
-2781
     /// S3 Snow Control without bucket
     #[test]
     fn test_108() {
         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)
             .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())
-2804
+                )
                 .build()
         );
-2807
+    }
-2808
     /// S3 Snow Control with bucket and without port
     #[test]
     fn test_109() {
         let params = crate::config::endpoint::Params::builder()
             .region("snow".to_string())
             .bucket("bucketName".to_string())
             .endpoint("https://10.0.1.12".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://10.0.1.12");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://10.0.1.12")
                 .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())
-2832
+                )
                 .build()
         );
-2835
+    }
-2836
     /// S3 Snow Control with bucket and with DNS
     #[test]
     fn test_110() {
         let params = crate::config::endpoint::Params::builder()
             .region("snow".to_string())
             .bucket("bucketName".to_string())
             .endpoint("http://s3snow.com".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://s3snow.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://s3snow.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(), "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())
-2860
+                )
                 .build()
         );
-2863
+    }
-2864
     /// S3 Snow Control with FIPS enabled
     #[test]
     fn test_111() {
         let params = crate::config::endpoint::Params::builder()
             .region("snow".to_string())
             .bucket("bucketName".to_string())
             .endpoint("https://10.0.1.12:433".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: S3 Snow does not support FIPS [S3 Snow Control with FIPS enabled]");
         assert_eq!(format!("{}", error), "S3 Snow does not support FIPS")
-2880
+    }
-2881
     /// S3 Snow Control with Dualstack enabled
     #[test]
     fn test_112() {
         let params = crate::config::endpoint::Params::builder()
             .region("snow".to_string())
             .bucket("bucketName".to_string())
             .endpoint("https://10.0.1.12:433".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: S3 Snow does not support DualStack [S3 Snow Control with Dualstack enabled]");
         assert_eq!(format!("{}", error), "S3 Snow does not support DualStack")
-2897
+    }
-2898
     /// Tagging on express bucket routed to s3express-control
     #[test]
     fn test_113() {
         let params = crate::config::endpoint::Params::builder()
             .resource_arn("arn:aws:s3express:us-east-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://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())
-2923
+                )
                 .build()
         );
-2926
+    }
-2927
     /// Tagging on express ap routed to s3express-control
     #[test]
     fn test_114() {
         let params = crate::config::endpoint::Params::builder()
             .resource_arn("arn:aws:s3express:us-east-1:871317572157:accesspoint/crachlintest--use1-az4--xa-s3".to_string())
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://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())
-2952
+                )
                 .build()
         );
-2955
+    }
-2956
     /// Tagging on express bucket routed to s3express-control FIPS when FIPS enabled
     #[test]
     fn test_115() {
         let params = crate::config::endpoint::Params::builder()
             .resource_arn("arn:aws:s3express:us-east-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://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())
-2981
+                )
                 .build()
         );
-2984
+    }
-2985
     /// Tagging on express bucket cn routed to s3express-control china endpoint
     #[test]
     fn test_116() {
         let params = crate::config::endpoint::Params::builder()
             .resource_arn("arn:aws-cn:s3express:cn-north-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
             .account_id("871317572157".to_string())
             .region("cn-north-1".to_string())
             .requires_account_id(true)
             .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://s3express-control.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control.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(), "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())
-3010
+                )
                 .build()
         );
-3013
+    }
-3014
     /// Tagging on express bucket cn routed to s3express-control china endpoint with FIPS
     #[test]
     fn test_117() {
         let params = crate::config::endpoint::Params::builder()
             .resource_arn("arn:aws-cn:s3express:cn-north-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
             .account_id("871317572157".to_string())
             .region("cn-north-1".to_string())
             .requires_account_id(true)
             .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 [Tagging on express bucket cn routed to s3express-control china endpoint with FIPS]",
         );
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-3033
+    }
-3034
     /// Tagging on express bucket with custom endpoint routed to custom endpoint
     #[test]
     fn test_118() {
         let params = crate::config::endpoint::Params::builder()
             .resource_arn("arn:aws:s3express:us-east-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
             .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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.express-control.s3.aws.dev");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://my-endpoint.express-control.s3.aws.dev")
                 .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())
-3060
+                )
                 .build()
         );
-3063
+    }
-3064
     /// Tagging on express access point with custom endpoint routed to custom endpoint
     #[test]
     fn test_119() {
         let params = crate::config::endpoint::Params::builder()
             .resource_arn("arn:aws:s3express:us-east-1:871317572157:accesspoint/crachlintest--use1-az4--xa-s3".to_string())
             .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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.express-control.s3.aws.dev");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://my-endpoint.express-control.s3.aws.dev")
                 .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())
-3090
+                )
                 .build()
         );
-3093
+    }
-3094
     /// Tagging on express bucket with dualstack and custom endpoint fails
     #[test]
     fn test_120() {
         let params = crate::config::endpoint::Params::builder()
             .resource_arn("arn:aws:s3express:us-east-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
             .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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: Invalid Configuration: DualStack and custom endpoint are not supported [Tagging on express bucket with dualstack and custom endpoint fails]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: DualStack and custom endpoint are not supported"
-3114
+        )
-3115
+    }
-3116
     /// Access Point APIs on express bucket routed to s3express-control
     #[test]
     fn test_121() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())
             .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://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())
-3141
+                )
                 .build()
         );
-3144
+    }
-3145
     /// Access Point APIs on express bucket routed to s3express-control for List
     #[test]
     fn test_122() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .use_s3_express_control_endpoint(true)
             .requires_account_id(true)
             .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://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())
-3170
+                )
                 .build()
         );
-3173
+    }
-3174
     /// Access Point APIs on express bucket routed to s3express-control for FIPS
     #[test]
     fn test_123() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())
             .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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://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())
-3199
+                )
                 .build()
         );
-3202
+    }
-3203
     /// Access Point APIs on express bucket routed to s3express-control for FIPS for List
     #[test]
     fn test_124() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .use_s3_express_control_endpoint(true)
             .requires_account_id(true)
             .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://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())
-3228
+                )
                 .build()
         );
-3231
+    }
-3232
     /// Access Point APIs on express bucket routed to s3express-control for china region
     #[test]
     fn test_125() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
             .account_id("871317572157".to_string())
             .region("cn-north-1".to_string())
             .requires_account_id(true)
             .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://s3express-control.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control.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(), "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())
-3257
+                )
                 .build()
         );
-3260
+    }
-3261
     /// Access Point APIs on express bucket routed to s3express-control for china region for List
     #[test]
     fn test_126() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())
             .region("cn-north-1".to_string())
             .use_s3_express_control_endpoint(true)
             .requires_account_id(true)
             .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://s3express-control.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://s3express-control.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(), "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())
-3286
+                )
                 .build()
         );
-3289
+    }
-3290
     /// Error when Access Point APIs on express bucket routed to s3express-control for china and FIPS
     #[test]
     fn test_127() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())
             .region("cn-north-1".to_string())
             .requires_account_id(true)
             .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 [Error when Access Point APIs on express bucket routed to s3express-control for china and FIPS]");
         assert_eq!(format!("{}", error), "Partition does not support FIPS")
-3306
+    }
-3307
     /// Error Access Point APIs on express bucket routed to s3express-control invalid zone
     #[test]
     fn test_128() {
         let params = crate::config::endpoint::Params::builder()
             .access_point_name("myaccesspoint-garbage-zone--xa-s3".to_string())
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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: Unrecognized S3Express Access Point name format. [Error Access Point APIs on express bucket routed to s3express-control invalid zone]");
         assert_eq!(format!("{}", error), "Unrecognized S3Express Access Point name format.")
-3324
+    }
-3325
     /// Access Point APIs on express bucket routed to custom endpoint if provided
     #[test]
     fn test_129() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())
             .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
             .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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.express-control.s3.aws.dev");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://my-endpoint.express-control.s3.aws.dev")
                 .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())
-3351
+                )
                 .build()
         );
-3354
+    }
-3355
     /// Access Point APIs on express bucket routed to custom endpoint if provided for List
     #[test]
     fn test_130() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())
             .use_s3_express_control_endpoint(true)
             .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
             .requires_account_id(true)
             .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.express-control.s3.aws.dev");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://my-endpoint.express-control.s3.aws.dev")
                 .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())
-3381
+                )
                 .build()
         );
-3384
+    }
-3385
     /// Error on Access Point APIs on express bucket for dual stack
     #[test]
     fn test_131() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())

↧ Expand context

             .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
             .region("us-east-1".to_string())
             .requires_account_id(true)
             .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: S3Express does not support Dual-stack. [Error on Access Point APIs on express bucket for dual stack]");
         assert_eq!(format!("{}", error), "S3Express does not support Dual-stack.")
-3403
+    }
-3404
     /// Error Access Point APIs on express bucket for dual stack for List
     #[test]
     fn test_132() {
         let params = crate::config::endpoint::Params::builder()
             .account_id("871317572157".to_string())
             .region("us-east-1".to_string())

@@ -4001,3473 +4139,7552 @@

↥ Expand context

-3473
     /// 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,
-3480
+    {
         ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
-3482
+    }
-3483
+}
-3484
 #[derive(Debug)]
 struct DowncastParams<T>(T);
 impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
 where
     T: ResolveEndpoint,
-3490
+{
     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
-3500
+    }
-3501
+}
-3502
 /// The default endpoint resolver
 #[derive(Debug, Default)]
 #[derive(Debug)]
 /// The default endpoint resolver.
 pub struct DefaultResolver {
     partition_resolver: crate::endpoint_lib::partition::PartitionResolver,
     partition_resolver: &'static crate::endpoint_lib::partition::PartitionResolver,
     endpoint_cache: ::arc_swap::ArcSwap<::std::option::Option<(Params, ::aws_smithy_types::endpoint::Endpoint)>>,
-+
+}
-+
 impl Default for DefaultResolver {
     fn default() -> Self {
         Self::new()
-+
+    }
-3514
+}
-3515
 impl DefaultResolver {
     /// Create a new endpoint resolver with default settings
     /// Create a new DefaultResolver
     pub fn new() -> Self {
         Self {
             partition_resolver: crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER.clone(),
--
+        }
--
+    }
--
     fn resolve_endpoint(
         &self,
         params: &crate::config::endpoint::Params,
             partition_resolver: &crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER,
             endpoint_cache: ::arc_swap::ArcSwap::from_pointee(None),
-+
+        }
-+
+    }
-+
     #[allow(
         unused_variables,
         unused_parens,
         clippy::double_parens,
         clippy::useless_conversion,
         clippy::bool_comparison,
         clippy::comparison_to_empty,
         clippy::needless_borrow,
         clippy::useless_asref,
         clippy::redundant_closure_call,
         clippy::clone_on_copy
     )]
     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();
         Ok(
             crate::config::endpoint::internals::resolve_endpoint(params, &mut diagnostic_collector, &self.partition_resolver)
                 .map_err(|err| err.with_source(diagnostic_collector.take_last_error()))?,
         let mut _diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
         #[allow(unused_mut)]
         let mut context = ConditionContext::default();
-+
         // Param bindings
         let region = &params.region;
         let use_fips = &params.use_fips;
         let use_dual_stack = &params.use_dual_stack;
         let endpoint = &params.endpoint;
         let account_id = &params.account_id;
         let requires_account_id = &params.requires_account_id;
         let outpost_id = &params.outpost_id;
         let bucket = &params.bucket;
         let access_point_name = &params.access_point_name;
         let use_arn_region = &params.use_arn_region;
         let resource_arn = &params.resource_arn;
         let use_s3_express_control_endpoint = &params.use_s3_express_control_endpoint;
-+
         let mut current_ref: i32 = 428;
         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(
                             "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(
                             "AccountId is required but not set".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "AccountId must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "OutpostId must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Invalid Configuration: DualStack and custom endpoint are not supported".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-3605
+                            )
-3606
+                        }
--
+}
--
 impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
     fn resolve_endpoint(&self, params: &crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'_> {
         ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(self.resolve_endpoint(params))
--
+    }
--
+}
--
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 /// Configuration parameters for resolving the correct endpoint
 pub struct Params {
     /// The AWS region used to dispatch the request.
     pub(crate) region: ::std::option::Option<::std::string::String>,
     /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
     pub(crate) use_fips: bool,
     /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
     pub(crate) use_dual_stack: bool,
     /// Override the endpoint used to send this request
     pub(crate) endpoint: ::std::option::Option<::std::string::String>,
     /// The Account ID used to send the request. This is an optional parameter that will be set automatically for operations that require it.
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     /// Internal parameter for operations that require account id host prefix.
     pub(crate) requires_account_id: ::std::option::Option<bool>,
     /// The Outpost ID.  Some operations have an optional OutpostId which should be used in endpoint construction.
     pub(crate) outpost_id: ::std::option::Option<::std::string::String>,
     /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     /// The S3 AccessPointName used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 AccessPoint.
     pub(crate) access_point_name: ::std::option::Option<::std::string::String>,
     /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
     pub(crate) use_arn_region: ::std::option::Option<bool>,
     /// The resource ARN included in the request.  Only set on TagResource, UntagResourceand ListTagsForResource
     pub(crate) resource_arn: ::std::option::Option<::std::string::String>,
     /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. ListDirectoryAccessPoints)
     pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
--
+}
 impl Params {
     /// Create a builder for [`Params`]
     pub fn builder() -> crate::config::endpoint::ParamsBuilder {
         crate::config::endpoint::ParamsBuilder::default()
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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-outposts-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dual_stack_dns_suffix());
                                         out
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-3630
+                        }
     /// The AWS region used to dispatch the request.
     pub fn region(&self) -> ::std::option::Option<&str> {
         self.region.as_deref()
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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-outposts-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-3654
+                        }
     /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
     pub fn use_fips(&self) -> ::std::option::Option<bool> {
         Some(self.use_fips)
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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-outposts.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&region.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&partition_result.dual_stack_dns_suffix());
                                         out
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-3678
+                        }
     /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
     pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
         Some(self.use_dual_stack)
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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-outposts.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-3702
+                        }
     /// Override the endpoint used to send this request
 => ::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),
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             let resource_arn_ctx_1 = context
                                 .resource_arn_ctx_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 configuration: region from ARN `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&resource_arn_ctx_1.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(
                             "S3Express does not support Dual-stack.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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());
                                         out
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3express")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3express")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3express")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let arn_partition_ssa_3 = context
                                 .arn_partition_ssa_3
                                 .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(&partition_result.name());
                                 out.push_str("` but ARN has `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&arn_partition_ssa_3.name());
                                 out.push('`');
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Unrecognized S3Express Access Point name format.".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 Snow does not support DualStack".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "S3 Snow does not support FIPS".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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());
                                         out
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             let access_point_arn = context.access_point_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(&access_point_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)
-+
+                        }
 => {
                             let account_id = params.account_id.as_deref().unwrap_or_default();
                             let access_point_arn = context.access_point_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 accountId specified in the ARN (`");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&access_point_arn.account_id());
                                 out.push_str("`) does not match the parameter (`");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&account_id.as_ref());
                                 out.push_str("`)");
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => {
                             let access_point_arn = context.access_point_arn.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 arn_partition_ssa_1 = context
                                 .arn_partition_ssa_1
                                 .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-outposts-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&access_point_arn.region());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&arn_partition_ssa_1.dual_stack_dns_suffix());
                                         out
                                     })
                                     .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", access_point_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let access_point_arn = context.access_point_arn.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 arn_partition_ssa_1 = context
                                 .arn_partition_ssa_1
                                 .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-outposts-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&access_point_arn.region());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&arn_partition_ssa_1.dns_suffix());
                                         out
                                     })
                                     .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", access_point_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let access_point_arn = context.access_point_arn.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 arn_partition_ssa_1 = context
                                 .arn_partition_ssa_1
                                 .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-outposts.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&access_point_arn.region());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&arn_partition_ssa_1.dual_stack_dns_suffix());
                                         out
                                     })
                                     .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", access_point_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let access_point_arn = context.access_point_arn.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.");
                             ::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
                                     })
                                     .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", access_point_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let access_point_arn = context.access_point_arn.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 arn_partition_ssa_1 = context
                                 .arn_partition_ssa_1
                                 .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-outposts.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&access_point_arn.region());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&arn_partition_ssa_1.dns_suffix());
                                         out
                                     })
                                     .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", access_point_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let outpost_type_ssa_1 = context
                                 .outpost_type_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("Expected an outpost type `accesspoint`, found `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&outpost_type_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: 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 access_point_arn = context.access_point_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(&access_point_arn.account_id());
                                 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: missing account ID".to_string(),
                         )) as ::aws_smithy_runtime_api::box_error::BoxError),
 => {
                             let access_point_arn = context.access_point_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(&access_point_arn.region());
                                 out.push_str("` (invalid DNS name)");
                                 out
                             })) 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 arn_partition_ssa_1 = context
                                 .arn_partition_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("Client was configured for partition `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&partition_result.name());
                                 out.push_str("` but ARN has `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&arn_partition_ssa_1.name());
                                 out.push('`');
                                 out
                             })) 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 must 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),
 => ::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 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)
-+
+                        }
 => {
                             let account_id = params.account_id.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 ARN: the accountId specified in the ARN (`");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&bucket_arn.account_id());
                                 out.push_str("`) does not match the parameter (`");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&account_id.as_ref());
                                 out.push_str("`)");
                                 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.");
                             let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             let arn_partition_ssa_2 = context
                                 .arn_partition_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://s3-outposts-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_arn.region());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&arn_partition_ssa_2.dual_stack_dns_suffix());
                                         out
                                     })
                                     .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", bucket_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let bucket_arn = context.bucket_arn.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.");
                             let arn_partition_ssa_2 = context
                                 .arn_partition_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://s3-outposts-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_arn.region());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&arn_partition_ssa_2.dns_suffix());
                                         out
                                     })
                                     .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", bucket_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let bucket_arn = context.bucket_arn.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.");
                             let arn_partition_ssa_2 = context
                                 .arn_partition_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://s3-outposts.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_arn.region());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&arn_partition_ssa_2.dual_stack_dns_suffix());
                                         out
                                     })
                                     .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", bucket_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             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 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();
                                         #[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
                                     })
                                     .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", bucket_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let bucket_arn = context.bucket_arn.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.");
                             let arn_partition_ssa_2 = context
                                 .arn_partition_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://s3-outposts.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&bucket_arn.region());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&arn_partition_ssa_2.dns_suffix());
                                         out
                                     })
                                     .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                     .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3-outposts")
                                             .put("signingRegion", bucket_arn.region()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let outpost_type_ssa_2 = context
                                 .outpost_type_ssa_2
                                 .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: Expected an outpost type `bucket`, found `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&outpost_type_ssa_2.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: expected a bucket name".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.");
                             ::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_arn.account_id());
                                 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 region in ARN: `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&bucket_arn.region());
                                 out.push_str("` (invalid DNS name)");
                                 out
                             })) 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 arn_partition_ssa_2 = context
                                 .arn_partition_ssa_2
                                 .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(&partition_result.name());
                                 out.push_str("` but ARN has `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&arn_partition_ssa_2.name());
                                 out.push('`');
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => {
                             let outpost_id_ssa_2 = context.outpost_id_ssa_2.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 must only contain a-z, A-Z, 0-9 and `-`., found: `");
                                 #[allow(clippy::needless_borrow)]
                                 out.push_str(&outpost_id_ssa_2.as_ref());
                                 out.push('`');
                                 out
                             })) as ::aws_smithy_runtime_api::box_error::BoxError)
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             let account_id = params.account_id.as_deref().unwrap_or_default();
                             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(&account_id.as_ref());
                                         out.push('.');
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.authority());
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&url.path());
                                         out
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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
                                     })
                                     .auth_scheme(
                                         ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             let account_id = params.account_id.as_deref().unwrap_or_default();
                             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(&account_id.as_ref());
                                         out.push_str(".s3-control-fips.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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-control-fips.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             let account_id = params.account_id.as_deref().unwrap_or_default();
                             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(&account_id.as_ref());
                                         out.push_str(".s3-control-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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-control-fips.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             let account_id = params.account_id.as_deref().unwrap_or_default();
                             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(&account_id.as_ref());
                                         out.push_str(".s3-control.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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-control.dualstack.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             let account_id = params.account_id.as_deref().unwrap_or_default();
                             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(&account_id.as_ref());
                                         out.push_str(".s3-control.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => {
                             let region = params.region.as_deref().unwrap_or_default();
                             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-control.");
                                         #[allow(clippy::needless_borrow)]
                                         out.push_str(&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("sigv4".to_string(), 3)
                                             .put("disableDoubleEncoding", true)
                                             .put("signingName", "s3")
                                             .put("signingRegion", region.as_ref()),
-+
+                                    )
                                     .build(),
-+
+                            )
-+
+                        }
 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                             "Region must be set".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 partition_result = &mut context.partition_result;
                             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),
 => (use_fips) == (&true),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_result = &context.partition_result;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = partition_result {
                                 inner.name()
                             } else {
                                 return false;
                             }) == ("aws-cn")
                         })(&mut _diagnostic_collector),
 => outpost_id.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(param) = outpost_id { param } else { return false },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => resource_arn.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let resource_arn_ctx_1 = &mut context.resource_arn_ctx_1;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *resource_arn_ctx_1 = crate::endpoint_lib::arn::parse_arn(
                                     if let Some(param) = resource_arn { param } else { return false },
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 resource_arn_ctx_1.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let resource_arn_ctx_1 = &context.resource_arn_ctx_1;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = resource_arn_ctx_1 {
                                 inner.service()
                             } else {
                                 return false;
                             }) == ("s3express")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let resource_arn_ctx_1 = &context.resource_arn_ctx_1;
                             let arn_partition_ssa_3 = &mut context.arn_partition_ssa_3;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *arn_partition_ssa_3 = partition_resolver
                                     .resolve_partition(
                                         if let Some(inner) = resource_arn_ctx_1 {
                                             inner.region()
                                         } else {
                                             return false;
                                         },
                                         _diagnostic_collector,
-+
+                                    )
                                     .map(|inner| inner.into());
                                 arn_partition_ssa_3.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_result = &context.partition_result;
                             let arn_partition_ssa_3 = &context.arn_partition_ssa_3;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = arn_partition_ssa_3 {
                                 inner.name()
                             } else {
                                 return false;
                             }) == (if let Some(inner) = partition_result {
                                 inner.name()
                             } else {
                                 return false;
                             })
                         })(&mut _diagnostic_collector),
 => endpoint.is_some(),
 => (use_dual_stack) == (&true),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(use_s3_express_control_endpoint.clone(), false)) == (true)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let url = &mut context.url;
                             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),
 => access_point_name.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 "".to_string()
                             )) == ("--xa-s3")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::substring::substring(
                                 if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                 true,
                                 _diagnostic_collector,
                             ))
                             .is_some()
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 "".to_string()
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::substring::substring(
                                 if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                 true,
                                 _diagnostic_collector,
                             ))
                             .is_some()
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (region) == &mut Some(("snow".to_string().into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &mut context.access_point_arn;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *access_point_arn = crate::endpoint_lib::arn::parse_arn(
                                     if let Some(param) = access_point_name { param } else { return false },
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 access_point_arn.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let arn_type_ssa_1 = &mut context.arn_type_ssa_1;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *arn_type_ssa_1 = if let Some(inner) = access_point_arn {
                                     inner.resource_id().first().cloned()
                                 } else {
                                     return false;
-+
+                                }
                                 .map(|inner| inner.into());
                                 arn_type_ssa_1.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => bucket.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let bucket_arn = &mut context.bucket_arn;
                             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 bucket_arn = &context.bucket_arn;
                             let arn_type_ssa_2 = &mut context.arn_type_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *arn_type_ssa_2 = if let Some(inner) = bucket_arn {
                                     inner.resource_id().first().cloned()
                                 } else {
                                     return false;
-+
+                                }
                                 .map(|inner| inner.into());
                                 arn_type_ssa_2.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let arn_type_ssa_2 = &context.arn_type_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (arn_type_ssa_2) == &mut Some(("".to_string().into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let bucket_arn = &context.bucket_arn;
                             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 bucket_arn = &context.bucket_arn;
                             let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *outpost_id_ssa_2 = if let Some(inner) = bucket_arn {
                                     inner.resource_id().get(1).cloned()
                                 } else {
                                     return false;
-+
+                                }
                                 .map(|inner| inner.into());
                                 outpost_id_ssa_2.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 "".to_string()
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let arn_type_ssa_1 = &context.arn_type_ssa_1;
                             let partition_resolver = &self.partition_resolver;
                             (arn_type_ssa_1) == &mut Some(("".to_string().into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = access_point_arn {
                                 inner.service()
                             } else {
                                 return false;
                             }) == ("s3-outposts")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *outpost_id_ssa_1 = if let Some(inner) = access_point_arn {
                                     inner.resource_id().get(1).cloned()
                                 } else {
                                     return false;
-+
+                                }
                                 .map(|inner| inner.into());
                                 outpost_id_ssa_1.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => account_id.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(param) = account_id { param } else { return false },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(requires_account_id.clone(), false)) == (true)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let partition_resolver = &self.partition_resolver;
                             (account_id)
                                 == &mut Some(
                                     (if let Some(inner) = access_point_arn {
                                         inner.account_id()
                                     } else {
                                         return false;
-+
+                                    }
                                     .into()),
-+
+                                )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             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 bucket_arn = &context.bucket_arn;
                             let partition_resolver = &self.partition_resolver;
                             (account_id)
                                 == &mut Some(
                                     (if let Some(inner) = bucket_arn {
                                         inner.account_id()
                                     } else {
                                         return false;
-+
+                                    }
                                     .into()),
-+
+                                )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(use_arn_region.clone(), true)) == (true)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let outpost_id_ssa_2 = &context.outpost_id_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 access_point_arn = &context.access_point_arn;
                             let partition_resolver = &self.partition_resolver;
                             (region)
                                 == &mut Some(
                                     (if let Some(inner) = access_point_arn {
                                         inner.region()
                                     } else {
                                         return false;
-+
+                                    }
                                     .into()),
-+
+                                )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let bucket_arn = &context.bucket_arn;
                             let partition_resolver = &self.partition_resolver;
                             (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 bucket_arn = &context.bucket_arn;
                             let arn_partition_ssa_2 = &mut context.arn_partition_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *arn_partition_ssa_2 = partition_resolver
                                     .resolve_partition(
                                         if let Some(inner) = bucket_arn { inner.region() } else { return false },
                                         _diagnostic_collector,
-+
+                                    )
                                     .map(|inner| inner.into());
                                 arn_partition_ssa_2.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_result = &context.partition_result;
                             let arn_partition_ssa_2 = &context.arn_partition_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = arn_partition_ssa_2 {
                                 inner.name()
                             } else {
                                 return false;
                             }) == (if let Some(inner) = partition_result {
                                 inner.name()
                             } else {
                                 return false;
                             })
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let bucket_arn = &context.bucket_arn;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(inner) = bucket_arn { inner.region() } else { return false },
                                 true,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let bucket_arn = &context.bucket_arn;
                             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 bucket_arn = &context.bucket_arn;
                             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,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let outpost_id_ssa_1 = &context.outpost_id_ssa_1;
                             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,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let arn_partition_ssa_1 = &mut context.arn_partition_ssa_1;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *arn_partition_ssa_1 = partition_resolver
                                     .resolve_partition(
                                         if let Some(inner) = access_point_arn {
                                             inner.region()
                                         } else {
                                             return false;
                                         },
                                         _diagnostic_collector,
-+
+                                    )
                                     .map(|inner| inner.into());
                                 arn_partition_ssa_1.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_result = &context.partition_result;
                             let arn_partition_ssa_1 = &context.arn_partition_ssa_1;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = arn_partition_ssa_1 {
                                 inner.name()
                             } else {
                                 return false;
                             }) == (if let Some(inner) = partition_result {
                                 inner.name()
                             } else {
                                 return false;
                             })
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(inner) = access_point_arn {
                                     inner.region()
                                 } else {
                                     return false;
                                 },
                                 true,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = access_point_arn {
                                 inner.account_id()
                             } else {
                                 return false;
                             }) == ("")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(inner) = access_point_arn {
                                     inner.account_id()
                                 } else {
                                     return false;
                                 },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::substring::substring(
                                 if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                 true,
                                 _diagnostic_collector,
                             ))
                             .is_some()
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 "".to_string()
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::substring::substring(
                                 if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                 true,
                                 _diagnostic_collector,
                             ))
                             .is_some()
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 "".to_string()
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let outpost_type_ssa_1 = &mut context.outpost_type_ssa_1;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *outpost_type_ssa_1 = if let Some(inner) = access_point_arn {
                                     inner.resource_id().get(2).cloned()
                                 } else {
                                     return false;
-+
+                                }
                                 .map(|inner| inner.into());
                                 outpost_type_ssa_1.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let access_point_arn = &context.access_point_arn;
                             let partition_resolver = &self.partition_resolver;
                             if let Some(inner) = access_point_arn {
                                 inner.resource_id().get(3).cloned()
                             } else {
                                 return false;
-+
+                            }
                             .is_some()
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let outpost_type_ssa_1 = &context.outpost_type_ssa_1;
                             let partition_resolver = &self.partition_resolver;
                             (outpost_type_ssa_1) == &mut Some(("accesspoint".to_string().into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::substring::substring(
                                 if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                 true,
                                 _diagnostic_collector,
                             ))
                             .is_some()
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (crate::endpoint_lib::coalesce::coalesce!(
                                 if let Some(inner) = crate::endpoint_lib::substring::substring(
                                     if let Some(param) = access_point_name { param } else { return false },
 ,
 ,
                                     true,
                                     _diagnostic_collector
                                 ) {
                                     inner
                                 } else {
                                     return false;
                                 },
                                 "".to_string()
                             )) == ("--")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let bucket_arn = &context.bucket_arn;
                             let outpost_type_ssa_2 = &mut context.outpost_type_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *outpost_type_ssa_2 = if let Some(inner) = bucket_arn {
                                     inner.resource_id().get(2).cloned()
                                 } else {
                                     return false;
-+
+                                }
                                 .map(|inner| inner.into());
                                 outpost_type_ssa_2.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let bucket_arn = &context.bucket_arn;
                             let partition_resolver = &self.partition_resolver;
                             if let Some(inner) = bucket_arn {
                                 inner.resource_id().get(3).cloned()
                             } else {
                                 return false;
-+
+                            }
                             .is_some()
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let outpost_type_ssa_2 = &context.outpost_type_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (outpost_type_ssa_2) == &mut Some(("bucket".to_string().into()))
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let resource_arn_ctx_1 = &context.resource_arn_ctx_1;
                             let partition_resolver = &self.partition_resolver;
                             (region)
                                 == &mut Some(
                                     (if let Some(inner) = resource_arn_ctx_1 {
                                         inner.region()
                                     } else {
                                         return false;
-+
+                                    }
                                     .into()),
-+
+                                )
                         })(&mut _diagnostic_collector),
                         _ => unreachable!("Invalid condition index"),
                     };
                     current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };
-+
+                }
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 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 (lock-free read via ArcSwap)
         let cached = self.endpoint_cache.load();
         if let Some((cached_params, cached_endpoint)) = cached.as_ref() {
             if cached_params == params {
                 return ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(::std::result::Result::Ok(cached_endpoint.clone()));
-+
+            }
-+
+        }
         drop(cached);
         let result = self.resolve_endpoint(params);
         if let ::std::result::Result::Ok(ref endpoint) = result {
             self.endpoint_cache.store(::std::sync::Arc::new(Some((params.clone(), endpoint.clone()))));
-+
+        }
         ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(result)
-+
+    }
-+
+}
 const NODES: [crate::endpoint_lib::bdd_interpreter::BddNode; 428] = [
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: -1,
         high_ref: 1,
         low_ref: -1,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 100000005,
         low_ref: 100000003,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 100000002,
         low_ref: 100000005,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 2,
         low_ref: 3,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000006,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 5,
         low_ref: 100000003,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 100000002,
         low_ref: 5,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 6,
         low_ref: 7,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000008,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 9,
         low_ref: 100000003,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 100000002,
         low_ref: 9,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 10,
         low_ref: 11,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 8,
         low_ref: 12,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 4,
         low_ref: 13,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000007,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 15,
         low_ref: 100000003,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 100000002,
         low_ref: 15,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 16,
         low_ref: 17,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 18,
         low_ref: 12,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 11,
         high_ref: 14,
         low_ref: 19,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 100000004,
         low_ref: 100000003,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 100000002,
         low_ref: 100000004,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 21,
         low_ref: 22,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 5,
         high_ref: 20,
         low_ref: 23,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 66,
         high_ref: 100000005,
         low_ref: 100000012,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 100000005,
         low_ref: 25,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 66,
         high_ref: 100000014,
         low_ref: 100000012,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 100000014,
         low_ref: 27,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 66,
         high_ref: 100000015,
         low_ref: 100000012,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 100000015,
         low_ref: 29,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 28,
         low_ref: 30,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 26,
         low_ref: 31,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 66,
         high_ref: 100000013,
         low_ref: 100000012,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 100000013,
         low_ref: 33,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 34,
         low_ref: 30,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 11,
         high_ref: 32,
         low_ref: 35,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 10,
         high_ref: 36,
         low_ref: 100000017,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 48,
         high_ref: 100000005,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 32,
         high_ref: 38,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 31,
         high_ref: 39,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 30,
         high_ref: 100000038,
         low_ref: 40,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 22,
         high_ref: 41,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 100000005,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 28,
         high_ref: 43,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 27,
         high_ref: 44,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000038,
         low_ref: 45,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 25,
         high_ref: 46,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000005,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000003,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 48,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000002,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 51,
         low_ref: 48,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 50,
         low_ref: 52,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 47,
         low_ref: 53,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 54,
         low_ref: 53,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 42,
         low_ref: 55,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 20,
         high_ref: 100000019,
         low_ref: 56,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 100000005,
         low_ref: 57,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 20,
         high_ref: 100000019,
         low_ref: 55,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 58,
         low_ref: 59,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000054,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000055,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 61,
         low_ref: 62,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 63,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 51,
         low_ref: 62,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 64,
         low_ref: 65,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 47,
         low_ref: 66,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 67,
         low_ref: 66,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 42,
         low_ref: 68,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 100000005,
         low_ref: 69,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 70,
         low_ref: 68,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 60,
         low_ref: 71,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 100000005,
         low_ref: 72,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 62,
         high_ref: 100000015,
         low_ref: 100000018,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 61,
         high_ref: 74,
         low_ref: 100000018,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 57,
         high_ref: 100000015,
         low_ref: 75,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 56,
         high_ref: 76,
         low_ref: 75,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 55,
         high_ref: 100000015,
         low_ref: 77,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 54,
         high_ref: 78,
         low_ref: 77,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 29,
         high_ref: 100000015,
         low_ref: 79,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 19,
         high_ref: 80,
         low_ref: 79,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 18,
         high_ref: 100000015,
         low_ref: 81,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 17,
         high_ref: 82,
         low_ref: 81,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 83,
         low_ref: 100000015,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 84,
         low_ref: 100000015,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 100000014,
         low_ref: 85,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 60,
         high_ref: 100000025,
         low_ref: 100000029,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 59,
         high_ref: 87,
         low_ref: 100000030,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 58,
         high_ref: 88,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 53,
         high_ref: 89,
         low_ref: 100000032,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 52,
         high_ref: 100000033,
         low_ref: 90,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 51,
         high_ref: 91,
         low_ref: 100000034,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 50,
         high_ref: 92,
         low_ref: 100000035,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 49,
         high_ref: 93,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 48,
         high_ref: 94,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 48,
         high_ref: 100000022,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 41,
         high_ref: 95,
         low_ref: 96,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 95,
         low_ref: 97,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 53,
         high_ref: 100000023,
         low_ref: 100000032,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 52,
         high_ref: 100000033,
         low_ref: 99,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 51,
         high_ref: 100,
         low_ref: 100000034,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 50,
         high_ref: 101,
         low_ref: 100000035,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 49,
         high_ref: 102,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 48,
         high_ref: 103,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 41,
         high_ref: 104,
         low_ref: 96,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 104,
         low_ref: 105,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 36,
         high_ref: 98,
         low_ref: 106,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 107,
         low_ref: 98,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 32,
         high_ref: 108,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 31,
         high_ref: 109,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 30,
         high_ref: 100000038,
         low_ref: 110,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 22,
         high_ref: 111,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 65,
         high_ref: 100000042,
         low_ref: 100000046,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 64,
         high_ref: 113,
         low_ref: 100000047,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 63,
         high_ref: 114,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 47,
         high_ref: 115,
         low_ref: 100000048,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 46,
         high_ref: 100000033,
         low_ref: 116,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 45,
         high_ref: 117,
         low_ref: 100000049,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 44,
         high_ref: 118,
         low_ref: 100000050,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 43,
         high_ref: 119,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 120,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 42,
         high_ref: 120,
         low_ref: 100000039,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 122,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 121,
         low_ref: 123,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 47,
         high_ref: 100000040,
         low_ref: 100000048,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 46,
         high_ref: 100000033,
         low_ref: 125,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 45,
         high_ref: 126,
         low_ref: 100000049,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 44,
         high_ref: 127,
         low_ref: 100000050,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 43,
         high_ref: 128,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 129,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 42,
         high_ref: 129,
         low_ref: 100000039,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 131,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 130,
         low_ref: 132,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 38,
         high_ref: 124,
         low_ref: 133,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 134,
         low_ref: 124,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 28,
         high_ref: 135,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 27,
         high_ref: 136,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000038,
         low_ref: 137,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 25,
         high_ref: 138,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000052,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000053,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 140,
         low_ref: 141,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 142,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 51,
         low_ref: 141,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 143,
         low_ref: 144,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 139,
         low_ref: 145,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 146,
         low_ref: 145,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 112,
         low_ref: 147,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 20,
         high_ref: 100000020,
         low_ref: 148,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 100000014,
         low_ref: 149,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 20,
         high_ref: 100000020,
         low_ref: 147,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 150,
         low_ref: 151,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000056,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000057,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 153,
         low_ref: 154,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 155,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 51,
         low_ref: 154,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 156,
         low_ref: 157,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 139,
         low_ref: 158,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 159,
         low_ref: 158,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 112,
         low_ref: 160,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 83,
         low_ref: 161,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 162,
         low_ref: 160,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 152,
         low_ref: 163,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 86,
         low_ref: 164,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 73,
         low_ref: 165,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 60,
         high_ref: 100000024,
         low_ref: 100000029,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 59,
         high_ref: 167,
         low_ref: 100000030,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 58,
         high_ref: 168,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 53,
         high_ref: 169,
         low_ref: 100000032,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 52,
         high_ref: 100000033,
         low_ref: 170,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 51,
         high_ref: 171,
         low_ref: 100000034,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 50,
         high_ref: 172,
         low_ref: 100000035,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 49,
         high_ref: 173,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 48,
         high_ref: 174,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 41,
         high_ref: 175,
         low_ref: 96,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 175,
         low_ref: 176,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 36,
         high_ref: 177,
         low_ref: 106,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 178,
         low_ref: 177,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 32,
         high_ref: 179,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 31,
         high_ref: 180,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 30,
         high_ref: 100000038,
         low_ref: 181,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 22,
         high_ref: 182,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 65,
         high_ref: 100000041,
         low_ref: 100000046,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 64,
         high_ref: 184,
         low_ref: 100000047,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 63,
         high_ref: 185,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 47,
         high_ref: 186,
         low_ref: 100000048,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 46,
         high_ref: 100000033,
         low_ref: 187,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 45,
         high_ref: 188,
         low_ref: 100000049,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 44,
         high_ref: 189,
         low_ref: 100000050,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 43,
         high_ref: 190,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 191,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 42,
         high_ref: 191,
         low_ref: 100000039,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 193,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 192,
         low_ref: 194,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 38,
         high_ref: 195,
         low_ref: 133,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 196,
         low_ref: 195,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 28,
         high_ref: 197,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 27,
         high_ref: 198,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000038,
         low_ref: 199,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 25,
         high_ref: 200,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 201,
         low_ref: 66,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 202,
         low_ref: 66,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 183,
         low_ref: 203,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 100000013,
         low_ref: 204,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 205,
         low_ref: 203,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 100000013,
         low_ref: 206,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 85,
         low_ref: 163,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 207,
         low_ref: 208,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 11,
         high_ref: 166,
         low_ref: 209,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 9,
         high_ref: 37,
         low_ref: 210,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 8,
         high_ref: 211,
         low_ref: 210,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 7,
         high_ref: 212,
         low_ref: 210,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 6,
         high_ref: 213,
         low_ref: 210,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 4,
         high_ref: 24,
         low_ref: 214,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 3,
         high_ref: 100000001,
         low_ref: 215,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000010,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 217,
         low_ref: 100000003,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 100000002,
         low_ref: 217,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 218,
         low_ref: 219,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 8,
         low_ref: 220,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 4,
         low_ref: 221,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000009,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 223,
         low_ref: 100000003,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 100000002,
         low_ref: 223,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 224,
         low_ref: 225,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 226,
         low_ref: 220,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 11,
         high_ref: 222,
         low_ref: 227,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 5,
         high_ref: 228,
         low_ref: 23,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 66,
         high_ref: 100000016,
         low_ref: 100000012,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 100000016,
         low_ref: 230,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 28,
         low_ref: 231,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 26,
         low_ref: 232,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 34,
         low_ref: 231,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 11,
         high_ref: 233,
         low_ref: 234,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 10,
         high_ref: 235,
         low_ref: 100000017,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000058,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000059,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 237,
         low_ref: 238,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 239,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 51,
         low_ref: 238,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 240,
         low_ref: 241,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 47,
         low_ref: 242,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 243,
         low_ref: 242,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 42,
         low_ref: 244,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 100000005,
         low_ref: 245,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 246,
         low_ref: 244,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 60,
         low_ref: 247,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 100000005,
         low_ref: 248,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 62,
         high_ref: 100000016,
         low_ref: 100000018,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 61,
         high_ref: 250,
         low_ref: 100000018,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 57,
         high_ref: 100000016,
         low_ref: 251,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 56,
         high_ref: 252,
         low_ref: 251,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 55,
         high_ref: 100000016,
         low_ref: 253,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 54,
         high_ref: 254,
         low_ref: 253,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 29,
         high_ref: 100000016,
         low_ref: 255,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 19,
         high_ref: 256,
         low_ref: 255,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 18,
         high_ref: 100000016,
         low_ref: 257,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 17,
         high_ref: 258,
         low_ref: 257,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 259,
         low_ref: 100000016,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 260,
         low_ref: 100000016,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 100000014,
         low_ref: 261,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 60,
         high_ref: 100000027,
         low_ref: 100000029,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 59,
         high_ref: 263,
         low_ref: 100000030,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 58,
         high_ref: 264,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 53,
         high_ref: 265,
         low_ref: 100000032,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 52,
         high_ref: 100000033,
         low_ref: 266,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 51,
         high_ref: 267,
         low_ref: 100000034,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 50,
         high_ref: 268,
         low_ref: 100000035,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 49,
         high_ref: 269,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 48,
         high_ref: 270,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 41,
         high_ref: 271,
         low_ref: 96,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 271,
         low_ref: 272,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 36,
         high_ref: 273,
         low_ref: 106,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 274,
         low_ref: 273,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 32,
         high_ref: 275,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 31,
         high_ref: 276,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 30,
         high_ref: 100000038,
         low_ref: 277,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 22,
         high_ref: 278,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 65,
         high_ref: 100000044,
         low_ref: 100000046,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 64,
         high_ref: 280,
         low_ref: 100000047,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 63,
         high_ref: 281,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 47,
         high_ref: 282,
         low_ref: 100000048,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 46,
         high_ref: 100000033,
         low_ref: 283,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 45,
         high_ref: 284,
         low_ref: 100000049,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 44,
         high_ref: 285,
         low_ref: 100000050,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 43,
         high_ref: 286,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 287,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 42,
         high_ref: 287,
         low_ref: 100000039,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 289,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 288,
         low_ref: 290,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 38,
         high_ref: 291,
         low_ref: 133,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 292,
         low_ref: 291,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 28,
         high_ref: 293,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 27,
         high_ref: 294,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000038,
         low_ref: 295,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 25,
         high_ref: 296,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 297,
         low_ref: 145,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 298,
         low_ref: 145,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 279,
         low_ref: 299,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 20,
         high_ref: 100000021,
         low_ref: 300,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 100000014,
         low_ref: 301,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 20,
         high_ref: 100000021,
         low_ref: 299,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 302,
         low_ref: 303,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 60,
         high_ref: 100000028,
         low_ref: 100000029,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 59,
         high_ref: 305,
         low_ref: 100000030,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 58,
         high_ref: 306,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 53,
         high_ref: 307,
         low_ref: 100000032,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 52,
         high_ref: 100000033,
         low_ref: 308,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 51,
         high_ref: 309,
         low_ref: 100000034,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 50,
         high_ref: 310,
         low_ref: 100000035,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 49,
         high_ref: 311,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 48,
         high_ref: 312,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 41,
         high_ref: 313,
         low_ref: 96,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 313,
         low_ref: 314,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 36,
         high_ref: 315,
         low_ref: 106,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 316,
         low_ref: 315,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 32,
         high_ref: 317,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 31,
         high_ref: 318,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 30,
         high_ref: 100000038,
         low_ref: 319,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 22,
         high_ref: 320,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 65,
         high_ref: 100000045,
         low_ref: 100000046,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 64,
         high_ref: 322,
         low_ref: 100000047,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 63,
         high_ref: 323,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 47,
         high_ref: 324,
         low_ref: 100000048,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 46,
         high_ref: 100000033,
         low_ref: 325,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 45,
         high_ref: 326,
         low_ref: 100000049,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 44,
         high_ref: 327,
         low_ref: 100000050,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 43,
         high_ref: 328,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 329,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 42,
         high_ref: 329,
         low_ref: 100000039,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 331,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 330,
         low_ref: 332,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 38,
         high_ref: 333,
         low_ref: 133,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 334,
         low_ref: 333,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 28,
         high_ref: 335,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 27,
         high_ref: 336,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000038,
         low_ref: 337,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 25,
         high_ref: 338,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000060,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 37,
         high_ref: 100000061,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 340,
         low_ref: 341,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 34,
         high_ref: 342,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 35,
         high_ref: 51,
         low_ref: 341,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 343,
         low_ref: 344,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 339,
         low_ref: 345,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 346,
         low_ref: 345,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 321,
         low_ref: 347,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 259,
         low_ref: 348,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 349,
         low_ref: 347,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 304,
         low_ref: 350,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 262,
         low_ref: 351,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 249,
         low_ref: 352,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 60,
         high_ref: 100000026,
         low_ref: 100000029,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 59,
         high_ref: 354,
         low_ref: 100000030,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 58,
         high_ref: 355,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 53,
         high_ref: 356,
         low_ref: 100000032,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 52,
         high_ref: 100000033,
         low_ref: 357,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 51,
         high_ref: 358,
         low_ref: 100000034,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 50,
         high_ref: 359,
         low_ref: 100000035,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 49,
         high_ref: 360,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 48,
         high_ref: 361,
         low_ref: 100000036,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 41,
         high_ref: 362,
         low_ref: 96,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 362,
         low_ref: 363,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 36,
         high_ref: 364,
         low_ref: 106,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 365,
         low_ref: 364,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 32,
         high_ref: 366,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 31,
         high_ref: 367,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 30,
         high_ref: 100000038,
         low_ref: 368,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 22,
         high_ref: 369,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 65,
         high_ref: 100000043,
         low_ref: 100000046,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 64,
         high_ref: 371,
         low_ref: 100000047,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 63,
         high_ref: 372,
         low_ref: 100000031,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 47,
         high_ref: 373,
         low_ref: 100000048,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 46,
         high_ref: 100000033,
         low_ref: 374,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 45,
         high_ref: 375,
         low_ref: 100000049,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 44,
         high_ref: 376,
         low_ref: 100000050,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 43,
         high_ref: 377,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 378,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 42,
         high_ref: 378,
         low_ref: 100000039,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 380,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 379,
         low_ref: 381,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 38,
         high_ref: 382,
         low_ref: 133,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 33,
         high_ref: 383,
         low_ref: 382,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 28,
         high_ref: 384,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 27,
         high_ref: 385,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000038,
         low_ref: 386,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 25,
         high_ref: 387,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 388,
         low_ref: 242,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 389,
         low_ref: 242,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 370,
         low_ref: 390,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 100000013,
         low_ref: 391,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 392,
         low_ref: 390,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 100000013,
         low_ref: 393,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 261,
         low_ref: 350,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 394,
         low_ref: 395,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 11,
         high_ref: 353,
         low_ref: 396,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 9,
         high_ref: 236,
         low_ref: 397,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 8,
         high_ref: 398,
         low_ref: 397,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 7,
         high_ref: 399,
         low_ref: 397,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 6,
         high_ref: 400,
         low_ref: 397,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 4,
         high_ref: 229,
         low_ref: 401,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 2,
         high_ref: 216,
         low_ref: 402,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 47,
         low_ref: 100000062,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 404,
         low_ref: 100000062,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 42,
         low_ref: 405,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 406,
         low_ref: 405,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 41,
         high_ref: 100000036,
         low_ref: 96,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 100000036,
         low_ref: 408,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 32,
         high_ref: 409,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 31,
         high_ref: 410,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 30,
         high_ref: 100000038,
         low_ref: 411,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 22,
         high_ref: 412,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 42,
         high_ref: 100000051,
         low_ref: 100000039,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 40,
         high_ref: 414,
         low_ref: 100000051,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 39,
         high_ref: 100000051,
         low_ref: 415,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 28,
         high_ref: 416,
         low_ref: 100000037,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 27,
         high_ref: 417,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000038,
         low_ref: 418,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 25,
         high_ref: 419,
         low_ref: 100000038,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 420,
         low_ref: 100000062,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 421,
         low_ref: 100000062,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 413,
         low_ref: 422,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 423,
         low_ref: 422,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 407,
         low_ref: 424,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 11,
         high_ref: 425,
         low_ref: 424,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 1,
         high_ref: 403,
         low_ref: 426,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 0,
         high_ref: 427,
         low_ref: 100000062,
     },
 ];
 // These are all optional since they are set by conditions and will
 // all be unset when we start evaluation
 #[derive(Default)]
 #[allow(unused_lifetimes)]
 pub(crate) struct ConditionContext<'a> {
     pub(crate) partition_result: Option<crate::endpoint_lib::partition::Partition<'a>>,
     pub(crate) resource_arn_ctx_1: Option<crate::endpoint_lib::arn::Arn<'a>>,
     pub(crate) arn_partition_ssa_3: Option<crate::endpoint_lib::partition::Partition<'a>>,
     pub(crate) url: Option<crate::endpoint_lib::parse_url::Url<'a>>,
     pub(crate) access_point_arn: Option<crate::endpoint_lib::arn::Arn<'a>>,
     pub(crate) arn_type_ssa_1: ::std::option::Option<::std::string::String>,
     pub(crate) bucket_arn: Option<crate::endpoint_lib::arn::Arn<'a>>,
     pub(crate) arn_type_ssa_2: ::std::option::Option<::std::string::String>,
     pub(crate) outpost_id_ssa_2: ::std::option::Option<::std::string::String>,
     pub(crate) outpost_id_ssa_1: ::std::option::Option<::std::string::String>,
     pub(crate) arn_partition_ssa_2: Option<crate::endpoint_lib::partition::Partition<'a>>,
     pub(crate) arn_partition_ssa_1: Option<crate::endpoint_lib::partition::Partition<'a>>,
     pub(crate) outpost_type_ssa_1: ::std::option::Option<::std::string::String>,
     pub(crate) outpost_type_ssa_2: ::std::option::Option<::std::string::String>,
     // Sometimes none of the members reference the lifetime, this makes it still valid
     phantom: std::marker::PhantomData<&'a ()>,
-+
+}
-+
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 /// Configuration parameters for resolving the correct endpoint
 pub struct Params {
     /// The AWS region used to dispatch the request.
     pub(crate) region: ::std::option::Option<::std::string::String>,
     /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
     pub(crate) use_fips: bool,
     /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
     pub(crate) use_dual_stack: bool,
     /// Override the endpoint used to send this request
     pub(crate) endpoint: ::std::option::Option<::std::string::String>,
     /// The Account ID used to send the request. This is an optional parameter that will be set automatically for operations that require it.
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     /// Internal parameter for operations that require account id host prefix.
     pub(crate) requires_account_id: ::std::option::Option<bool>,
     /// The Outpost ID.  Some operations have an optional OutpostId which should be used in endpoint construction.
     pub(crate) outpost_id: ::std::option::Option<::std::string::String>,
     /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
     pub(crate) bucket: ::std::option::Option<::std::string::String>,
     /// The S3 AccessPointName used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 AccessPoint.
     pub(crate) access_point_name: ::std::option::Option<::std::string::String>,
     /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
     pub(crate) use_arn_region: ::std::option::Option<bool>,
     /// The resource ARN included in the request.  Only set on TagResource, UntagResourceand ListTagsForResource
     pub(crate) resource_arn: ::std::option::Option<::std::string::String>,
     /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. ListDirectoryAccessPoints)
     pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
-+
+}
 impl Params {
     /// Create a builder for [`Params`]
     pub fn builder() -> crate::config::endpoint::ParamsBuilder {
         crate::config::endpoint::ParamsBuilder::default()
-+
+    }
     /// The AWS region used to dispatch the request.
     pub fn region(&self) -> ::std::option::Option<&str> {
         self.region.as_deref()
-+
+    }
     /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
     pub fn use_fips(&self) -> ::std::option::Option<bool> {
         Some(self.use_fips)
-+
+    }
     /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
     pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
         Some(self.use_dual_stack)
-+
+    }
     /// Override the endpoint used to send this request
     pub fn endpoint(&self) -> ::std::option::Option<&str> {
         self.endpoint.as_deref()
-7525
+    }
     /// The Account ID used to send the request. This is an optional parameter that will be set automatically for operations that require it.
     pub fn account_id(&self) -> ::std::option::Option<&str> {
         self.account_id.as_deref()
-7529
+    }
     /// Internal parameter for operations that require account id host prefix.
     pub fn requires_account_id(&self) -> ::std::option::Option<bool> {
         self.requires_account_id

↧ Expand context

-7533
+    }
     /// The Outpost ID.  Some operations have an optional OutpostId which should be used in endpoint construction.
     pub fn outpost_id(&self) -> ::std::option::Option<&str> {
         self.outpost_id.as_deref()
-7537
+    }
     /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
     pub fn bucket(&self) -> ::std::option::Option<&str> {
         self.bucket.as_deref()
-7541
+    }
     /// The S3 AccessPointName used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 AccessPoint.
     pub fn access_point_name(&self) -> ::std::option::Option<&str> {
         self.access_point_name.as_deref()
-7545
+    }
     /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
     pub fn use_arn_region(&self) -> ::std::option::Option<bool> {
         self.use_arn_region
-7549
+    }
     /// The resource ARN included in the request.  Only set on TagResource, UntagResourceand ListTagsForResource
     pub fn resource_arn(&self) -> ::std::option::Option<&str> {
         self.resource_arn.as_deref()

@@ -4388,7801 +4419,0 @@

↥ Expand context

-7801
+}
-7802
 impl InvalidParams {
     #[allow(dead_code)]
     fn missing(field: &'static str) -> Self {
         Self {
             field: field.into(),
             kind: InvalidParamsErrorKind::MissingField,
-7809
+        }
-7810
+    }
-7811
     #[allow(dead_code)]
     fn invalid_value(field: &'static str, message: &'static str) -> Self {
         Self {
             field: field.into(),
             kind: InvalidParamsErrorKind::InvalidValue { message },
-7817
+        }
-7818
+    }
-7819
+}
-7820

 impl std::fmt::Display for InvalidParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self.kind {
             InvalidParamsErrorKind::MissingField => write!(f, "a required field was missing: `{}`", self.field),
             InvalidParamsErrorKind::InvalidValue { message } => write!(f, "invalid value for field: `{}` - {}", self.field, message),
-7826
+        }
-7827
+    }
-7828
+}
-7829
 impl std::error::Error for InvalidParams {}
--
 mod internals;

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-sdk-s3control"
 version = "0.0.0-local"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
 description = "AWS SDK for AWS S3 Control"
 edition = "2021"

 license = "Apache-2.0"
 repository = "https://github.com/awslabs/aws-sdk-rust"
 rust-version = "1.91.1"
 readme = "README.md"
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "aws.protocols#restXml"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 [dependencies.arc-swap]
 version = "1"
-+
 [dependencies.aws-credential-types]
 path = "../aws-credential-types"
 version = "1.2.14"
-24
 [dependencies.aws-runtime]
 path = "../aws-runtime"
 version = "1.7.4"
-28
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"

 version = "1.2.14"
-32
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 version = "0.63.6"
-36
 [dependencies.aws-smithy-json]
 path = "../aws-smithy-json"
 version = "0.62.6"
-40
 [dependencies.aws-smithy-observability]
 path = "../aws-smithy-observability"
 version = "0.2.6"
-44
 [dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client"]
 version = "1.11.3"
-49
 [dependencies.aws-smithy-runtime-api]

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`impl super::Client {`

     /// Constructs a fluent builder for the [`CreateAccessPoint`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder) operation.
     ///
     /// - The fluent builder is configurable:
     ///   - [`account_id(impl Into<String>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::account_id) / [`set_account_id(Option<String>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::set_account_id):<br>required: **true**<br><p>The Amazon Web Services account ID for the account that owns the specified access point.</p><br>
     ///   - [`name(impl Into<String>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::name) / [`set_name(Option<String>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::set_name):<br>required: **true**<br><p>The name you want to assign to this access point.</p> <p>For directory buckets, the access point name must consist of a base name that you provide and suffix that includes the <code>ZoneID</code> (Amazon Web Services Availability Zone or Local Zone) of your bucket location, followed by <code>--xa-s3</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing access to shared datasets in directory buckets with access points</a> in the <i>Amazon S3 User Guide</i>.</p><br>
     ///   - [`bucket(impl Into<String>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::bucket) / [`set_bucket(Option<String>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::set_bucket):<br>required: **true**<br><p>The name of the bucket that you want to associate this access point with.</p> <p>For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.</p> <p>For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format <code>arn:aws:s3-outposts:<region>    :    <account-id>     :outpost/     <outpost-id>      /bucket/      <my-bucket-name></my-bucket-name>     </outpost-id>    </account-id>   </region></code>. For example, to access the bucket <code>reports</code> through Outpost <code>my-outpost</code> owned by account <code>123456789012</code> in Region <code>us-west-2</code>, use the URL encoding of <code>arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports</code>. The value must be URL encoded.</p><br>
     ///   - [`vpc_configuration(VpcConfiguration)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::vpc_configuration) / [`set_vpc_configuration(Option<VpcConfiguration>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::set_vpc_configuration):<br>required: **false**<br><p>If you include this field, Amazon S3 restricts access to this access point to requests from the specified virtual private cloud (VPC).</p><note>  <p>This is required for creating an access point for Amazon S3 on Outposts buckets.</p> </note><br>
     ///   - [`public_access_block_configuration(PublicAccessBlockConfiguration)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::public_access_block_configuration) / [`set_public_access_block_configuration(Option<PublicAccessBlockConfiguration>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::set_public_access_block_configuration):<br>required: **false**<br><p>The <code>PublicAccessBlock</code> configuration that you want to apply to the access point.</p><br>
     ///   - [`bucket_account_id(impl Into<String>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::bucket_account_id) / [`set_bucket_account_id(Option<String>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::set_bucket_account_id):<br>required: **false**<br><p>The Amazon Web Services account ID associated with the S3 bucket associated with this access point.</p> <p>For same account access point when your bucket and access point belong to the same account owner, the <code>BucketAccountId</code> is not required. For cross-account access point when your bucket and access point are not in the same account, the <code>BucketAccountId</code> is required.</p><br>
     ///   - [`scope(Scope)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::scope) / [`set_scope(Option<Scope>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::set_scope):<br>required: **false**<br><p>For directory buckets, you can filter access control to specific prefixes, API operations, or a combination of both. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing access to shared datasets in directory buckets with access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>  <p>Scope is only supported for access points attached to directory buckets.</p> </note><br>
     ///   - [`tags(Tag)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::tags) / [`set_tags(Option<Vec::<Tag>>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::set_tags):<br>required: **false**<br><p>An array of tags that you can apply to an access point. Tags are key-value pairs of metadata used to control access to your access points. For more information about tags, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/tagging.html">Using tags with Amazon S3</a>. For information about tagging access points, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/tagging.html#using-tags-for-abac">Using tags for attribute-based access control (ABAC)</a>.</p><note>  <ul>   <li>    <p>You must have the <code>s3:TagResource</code> permission to create an access point with tags for a general purpose bucket.</p></li>   <li>    <p>You must have the <code>s3express:TagResource</code> permission to create an access point with tags for a directory bucket.</p></li>  </ul> </note><br>
     ///   - [`tags(Tag)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::tags) / [`set_tags(Option<Vec::<Tag>>)`](crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::set_tags):<br>required: **false**<br><p>An array of tags that you can apply to an access point. Tags are key-value pairs of metadata used to control access to your access points. For more information about tags, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/tagging.html">Using tags with Amazon S3</a>. For information about tagging access points, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/tagging.html#using-tags-for-abac">Using tags for attribute-based access control (ABAC)</a>.</p><br>
     /// - On success, responds with [`CreateAccessPointOutput`](crate::operation::create_access_point::CreateAccessPointOutput) with field(s):
     ///   - [`access_point_arn(Option<String>)`](crate::operation::create_access_point::CreateAccessPointOutput::access_point_arn): <p>The ARN of the access point.</p><note>  <p>This is only supported by Amazon S3 on Outposts.</p> </note>
     ///   - [`alias(Option<String>)`](crate::operation::create_access_point::CreateAccessPointOutput::alias): <p>The name or alias of the access point.</p>
     /// - On failure, responds with [`SdkError<CreateAccessPointError>`](crate::operation::create_access_point::CreateAccessPointError)
     pub fn create_access_point(&self) -> crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder {
         crate::operation::create_access_point::builders::CreateAccessPointFluentBuilder::new(self.handle.clone())
-20
+    }
-21
+}

AWS SDK

Files changed:

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

tmp-codegen-diff/aws-sdk/sdk/s3control/src/client/create_access_point.rs

tmp-codegen-diff/aws-sdk/sdk/s3control/src/client/get_data_access.rs

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

 impl super::Client {
     /// Constructs a fluent builder for the [`GetDataAccess`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder) operation.
     ///
     /// - The fluent builder is configurable:
     ///   - [`account_id(impl Into<String>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::account_id) / [`set_account_id(Option<String>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::set_account_id):<br>required: **true**<br><p>The Amazon Web Services account ID of the S3 Access Grants instance.</p><br>
     ///   - [`target(impl Into<String>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::target) / [`set_target(Option<String>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::set_target):<br>required: **true**<br><p>The S3 URI path of the data to which you are requesting temporary access credentials. If the requesting account has an access grant for this data, S3 Access Grants vends temporary access credentials in the response.</p><br>
     ///   - [`permission(Permission)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::permission) / [`set_permission(Option<Permission>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::set_permission):<br>required: **true**<br><p>The type of permission granted to your S3 data, which can be set to one of the following values:</p> <ul>  <li>   <p><code>READ</code> – Grant read-only access to the S3 data.</p></li>  <li>   <p><code>WRITE</code> – Grant write-only access to the S3 data.</p></li>  <li>   <p><code>READWRITE</code> – Grant both read and write access to the S3 data.</p></li> </ul><br>
     ///   - [`duration_seconds(i32)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::duration_seconds) / [`set_duration_seconds(Option<i32>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::set_duration_seconds):<br>required: **false**<br><p>The session duration, in seconds, of the temporary access credential that S3 Access Grants vends to the grantee or client application. The default value is 1 hour, but the grantee can specify a range from 900 seconds (15 minutes) up to 43200 seconds (12 hours). If the grantee requests a value higher than this maximum, the operation fails.</p><br>
     ///   - [`privilege(Privilege)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::privilege) / [`set_privilege(Option<Privilege>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::set_privilege):<br>required: **false**<br><p>The scope of the temporary access credential that S3 Access Grants vends to the grantee or client application.</p> <ul>  <li>   <p><code>Default</code> – The scope of the returned temporary access token is the scope of the grant that is closest to the target scope.</p></li>  <li>   <p><code>Minimal</code> – The scope of the returned temporary access token is the same as the requested target scope as long as the requested scope is the same as or a subset of the grant scope.</p></li> </ul><br>
     ///   - [`target_type(S3PrefixType)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::target_type) / [`set_target_type(Option<S3PrefixType>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::set_target_type):<br>required: **false**<br><p>The type of <code>Target</code>. The only possible value is <code>Object</code>. Pass this value if the target data that you would like to access is a path to an object. Do not pass this value if the target data is a bucket or a bucket and a prefix.</p><br>
     ///   - [`audit_context(impl Into<String>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::audit_context) / [`set_audit_context(Option<String>)`](crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::set_audit_context):<br>required: **false**<br><p>The context to identify the job or query associated with the credential request. This information will be displayed in CloudTrail log in your account.</p><br>
     /// - On success, responds with [`GetDataAccessOutput`](crate::operation::get_data_access::GetDataAccessOutput) with field(s):
     ///   - [`credentials(Option<Credentials>)`](crate::operation::get_data_access::GetDataAccessOutput::credentials): <p>The temporary credential token that S3 Access Grants vends.</p>
     ///   - [`matched_grant_target(Option<String>)`](crate::operation::get_data_access::GetDataAccessOutput::matched_grant_target): <p>The S3 URI path of the data to which you are being granted temporary access credentials.</p>
     ///   - [`grantee(Option<Grantee>)`](crate::operation::get_data_access::GetDataAccessOutput::grantee): <p>The user, group, or role that was granted access to the S3 location scope. For directory identities, this API also returns the grants of the IAM role used for the identity-aware request. For more information on identity-aware sessions, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_sts-setcontext.html">Granting permissions to use identity-aware console sessions</a>.</p>
     /// - On failure, responds with [`SdkError<GetDataAccessError>`](crate::operation::get_data_access::GetDataAccessError)
     pub fn get_data_access(&self) -> crate::operation::get_data_access::builders::GetDataAccessFluentBuilder {
         crate::operation::get_data_access::builders::GetDataAccessFluentBuilder::new(self.handle.clone())
-20
+    }
-21
+}