AWS SDK

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

@@ -358,358 +427,421 @@

             .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://dynamodb.eu-west-3.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.eu-west-3.amazonaws.com")
                 .build()
         );
-370
+    }
-371
     /// For region local with FIPS disabled and DualStack disabled
     #[test]
     fn test_18() {
         let params = crate::config::endpoint::Params::builder()
             .region("local".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://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-392
+                )
                 .build()
         );
-395
+    }
-396
     /// For region me-south-1 with FIPS disabled and DualStack disabled
     #[test]
     fn test_19() {
         let params = crate::config::endpoint::Params::builder()
             .region("me-south-1".to_string())

↧ Expand context

             .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://dynamodb.me-south-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.me-south-1.amazonaws.com")
                 .build()
         );
-415
+    }
-416
     /// For region sa-east-1 with FIPS disabled and DualStack disabled
     #[test]
     fn test_20() {
         let params = crate::config::endpoint::Params::builder()
             .region("sa-east-1".to_string())

@@ -2578,2572 +2889,2835 @@

↥ Expand context

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and local endpoint are not supported [{UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=local}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: Dualstack and local endpoint are not supported"
-2581
+        )
-2582
+    }
-2583
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_127() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2606
+                )
                 .build()
         );
-2609
+    }
-2610
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_128() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2634
+                )
                 .build()
         );
-2637
+    }
-2638
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_129() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2663
+                )
                 .build()
         );
-2666
+    }
-2667
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_130() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2692
+                )
                 .build()
         );
-2695
+    }
-2696
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_131() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2721
+                )
                 .build()
         );
-2724
+    }
-2725
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_132() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-west-2:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2750
+                )
                 .build()
         );
-2753
+    }
-2754
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_133() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:s3:us-east-1:333333333333:stream/testStream".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2779
+                )
                 .build()
         );
-2782
+    }
-2783
     /// {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_134() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2806
+                )
                 .build()
         );
-2809
+    }
-2810
     /// {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_135() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

↧ Expand context

             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and local endpoint are not supported [{UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}]");
         assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and local endpoint are not supported")
-2826
+    }
-2827
     /// {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_136() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())

@@ -2907,2853 +3075,2997 @@

↥ Expand context

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and local endpoint are not supported [{UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: Dualstack and local endpoint are not supported"
-2862
+        )
-2863
+    }
-2864
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_138() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2887
+                )
                 .build()
         );
-2890
+    }
-2891
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_139() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2914
+                )
                 .build()
         );
-2917
+    }
-2918
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_140() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2941
+                )
                 .build()
         );
-2944
+    }
-2945
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_141() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-2968
+                )
                 .build()
         );
-2971
+    }
-2972
     /// {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_142() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

↧ Expand context

             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and local endpoint are not supported [{UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}]");
         assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and local endpoint are not supported")
-2988
+    }
-2989
     /// {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_143() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())

@@ -3093,3015 +3228,3132 @@

↥ Expand context

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and local endpoint are not supported [{UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: Dualstack and local endpoint are not supported"
-3024
+        )
-3025
+    }
-3026
     /// {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_145() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3049
+                )
                 .build()
         );
-3052
+    }
-3053
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_146() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3077
+                )
                 .build()
         );
-3080
+    }
-3081
     /// {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=local}
     #[test]
     fn test_147() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id_endpoint_mode("preferred".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3103
+                )
                 .build()
         );
-3106
+    }
-3107
     /// {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_148() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

↧ Expand context

             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and local endpoint are not supported [{UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=local}]");
         assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and local endpoint are not supported")
-3123
+    }
-3124
     /// {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_149() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("disabled".to_string())

@@ -3246,3150 +3557,3413 @@

↥ Expand context

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and local endpoint are not supported [{UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=local}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: Dualstack and local endpoint are not supported"
-3159
+        )
-3160
+    }
-3161
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_151() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("disabled".to_string())

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3184
+                )
                 .build()
         );
-3187
+    }
-3188
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_152() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3212
+                )
                 .build()
         );
-3215
+    }
-3216
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_153() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3241
+                )
                 .build()
         );
-3244
+    }
-3245
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_154() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3270
+                )
                 .build()
         );
-3273
+    }
-3274
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_155() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3299
+                )
                 .build()
         );
-3302
+    }
-3303
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_156() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-west-2:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3328
+                )
                 .build()
         );
-3331
+    }
-3332
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_157() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:s3:us-east-1:333333333333:stream/testStream".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3357
+                )
                 .build()
         );
-3360
+    }
-3361
     /// {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_158() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("".to_string())
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3384
+                )
                 .build()
         );
-3387
+    }
-3388
     /// {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_159() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

↧ Expand context

             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and local endpoint are not supported [{UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}]");
         assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and local endpoint are not supported")
-3404
+    }
-3405
     /// {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_160() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("disabled".to_string())

@@ -3575,3431 +3743,3575 @@

↥ Expand context

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and local endpoint are not supported [{UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: Dualstack and local endpoint are not supported"
-3440
+        )
-3441
+    }
-3442
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_162() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("disabled".to_string())

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3465
+                )
                 .build()
         );
-3468
+    }
-3469
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_163() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3492
+                )
                 .build()
         );
-3495
+    }
-3496
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_164() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3519
+                )
                 .build()
         );
-3522
+    }
-3523
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_165() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("".to_string())
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3546
+                )
                 .build()
         );
-3549
+    }
-3550
     /// {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_166() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

↧ Expand context

             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and local endpoint are not supported [{UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}]");
         assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and local endpoint are not supported")
-3566
+    }
-3567
     /// {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_167() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())

@@ -3761,3593 +3896,3710 @@

↥ Expand context

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and local endpoint are not supported [{UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: Dualstack and local endpoint are not supported"
-3602
+        )
-3603
+    }
-3604
     /// {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_169() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3627
+                )
                 .build()
         );
-3630
+    }
-3631
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_170() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3655
+                )
                 .build()
         );
-3658
+    }
-3659
     /// {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=disabled, Region=local}
     #[test]
     fn test_171() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id_endpoint_mode("disabled".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3681
+                )
                 .build()
         );
-3684
+    }
-3685
     /// {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_172() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

↧ Expand context

             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and local endpoint are not supported [{UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=local}]");
         assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and local endpoint are not supported")
-3701
+    }
-3702
     /// {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_173() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("required".to_string())

@@ -3914,3728 +4225,3991 @@

↥ Expand context

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and local endpoint are not supported [{UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=local}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: Dualstack and local endpoint are not supported"
-3737
+        )
-3738
+    }
-3739
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_175() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("required".to_string())

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3762
+                )
                 .build()
         );
-3765
+    }
-3766
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_176() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3790
+                )
                 .build()
         );
-3793
+    }
-3794
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_177() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3819
+                )
                 .build()
         );
-3822
+    }
-3823
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_178() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3848
+                )
                 .build()
         );
-3851
+    }
-3852
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_179() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3877
+                )
                 .build()
         );
-3880
+    }
-3881
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_180() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-west-2:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3906
+                )
                 .build()
         );
-3909
+    }
-3910
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_181() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:s3:us-east-1:333333333333:stream/testStream".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3935
+                )
                 .build()
         );
-3938
+    }
-3939
     /// {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_182() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-3962
+                )
                 .build()
         );
-3965
+    }
-3966
     /// {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_183() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

↧ Expand context

             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and local endpoint are not supported [{UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}]");
         assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and local endpoint are not supported")
-3982
+    }
-3983
     /// {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_184() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())

@@ -4243,4009 +4411,4153 @@

↥ Expand context

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and local endpoint are not supported [{UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: Dualstack and local endpoint are not supported"
-4018
+        )
-4019
+    }
-4020
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_186() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-4043
+                )
                 .build()
         );
-4046
+    }
-4047
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_187() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-4070
+                )
                 .build()
         );
-4073
+    }
-4074
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_188() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-4097
+                )
                 .build()
         );
-4100
+    }
-4101
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_189() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-4124
+                )
                 .build()
         );
-4127
+    }
-4128
     /// {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_190() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

↧ Expand context

             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and local endpoint are not supported [{UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}]");
         assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and local endpoint are not supported")
-4144
+    }
-4145
     /// {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_191() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())

@@ -4429,4171 +4564,4288 @@

↥ Expand context

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and local endpoint are not supported [{UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: Dualstack and local endpoint are not supported"
-4180
+        )
-4181
+    }
-4182
     /// {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_193() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())

             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-4205
+                )
                 .build()
         );
-4208
+    }
-4209
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_194() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-4233
+                )
                 .build()
         );
-4236
+    }
-4237
     /// {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=required, Region=local}
     #[test]
     fn test_195() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id_endpoint_mode("required".to_string())
             .region("local".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: http://localhost:8000");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("http://localhost:8000")
                 .property(
                     "authSchemes",
                     vec![{
                         let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
                         out.insert("signingName".to_string(), "dynamodb".to_string().into());
                         out.insert("name".to_string(), "sigv4".to_string().into());
                         out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
                         out
--
+                    }
                     .into()]
                 .auth_scheme(
                     ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
                         .put("signingName", "dynamodb".to_string())
                         .put("signingRegion", "us-east-1".to_string())
-4259
+                )
                 .build()
         );
-4262
+    }
-4263
     /// {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_196() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

↧ Expand context

             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb-fips.us-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-east-1.api.aws")
                 .build()
         );
-4284
+    }
-4285
     /// {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_197() {

@@ -4567,4291 +4796,4528 @@

↥ Expand context

             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-east-1.amazonaws.com")
                 .build()
         );
-4306
+    }
-4307
     /// {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_198() {

         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb.us-east-1.api.aws");
         let endpoint = endpoint.expect("Expected valid endpoint: https://111111111111.ddb.us-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-east-1.api.aws")
                 .url("https://111111111111.ddb.us-east-1.api.aws")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4329
+    }
-4330
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_199() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://111111111111.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://111111111111.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4352
+    }
-4353
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_200() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://333333333333.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4376
+    }
-4377
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_201() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://222222222222.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://222222222222.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4401
+    }
-4402
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_202() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://333333333333.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4426
+    }
-4427
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_203() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://333333333333.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4451
+    }
-4452
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_204() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-west-2:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://111111111111.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://111111111111.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4476
+    }
-4477
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_205() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:s3:us-east-1:333333333333:stream/testStream".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://111111111111.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://111111111111.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4501
+    }
-4502
     /// {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_206() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)

↧ Expand context

             .account_id("".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Credentials-sourced account ID parameter is invalid [{UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=us-east-1}]");
         assert_eq!(format!("{}", error), "Credentials-sourced account ID parameter is invalid")
-4518
+    }
-4519
     /// {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_207() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())

@@ -4815,4547 +4901,4635 @@

↥ Expand context

             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-east-1.amazonaws.com")
                 .build()
         );
-4562
+    }
-4563
     /// {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_209() {

         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb.us-east-1.api.aws");
         let endpoint = endpoint.expect("Expected valid endpoint: https://222222222222.ddb.us-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-east-1.api.aws")
                 .url("https://222222222222.ddb.us-east-1.api.aws")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4585
+    }
-4586
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_210() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://222222222222.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://222222222222.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4608
+    }
-4609
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_211() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)

↧ Expand context

             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-east-1.amazonaws.com")
                 .build()
         );
-4630
+    }
-4631
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_212() {
         let params = crate::config::endpoint::Params::builder()

@@ -4969,4703 +5078,4815 @@

↥ Expand context

             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb-fips.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-east-1.amazonaws.com")
                 .build()
         );
-4718
+    }
-4719
     /// {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_216() {

         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb.us-east-1.api.aws");
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-east-1.api.aws")
                 .url("https://333333333333.ddb.us-east-1.api.aws")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4741
+    }
-4742
     /// {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_217() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://333333333333.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4764
+    }
-4765
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_218() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://222222222222.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://222222222222.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4788
+    }
-4789
     /// {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=us-east-1}
     #[test]
     fn test_219() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)

↧ Expand context

             .account_id_endpoint_mode("preferred".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-east-1.amazonaws.com")
                 .build()
         );
-4809
+    }
-4810
     /// {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_220() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)

@@ -5097,4834 +5324,5071 @@

↥ Expand context

         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported [{UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported"
-4848
+        )
-4849
+    }
-4850
     /// {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_222() {

         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported [{UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1}]");
         let endpoint = endpoint.expect("Expected valid endpoint: https://111111111111.ddb.us-east-1.api.aws");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported"
--
+        )
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://111111111111.ddb.us-east-1.api.aws")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4872
+    }
-4873
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_223() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://111111111111.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://111111111111.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4895
+    }
-4896
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_224() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://333333333333.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4919
+    }
-4920
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_225() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://222222222222.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://222222222222.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4944
+    }
-4945
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_226() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://333333333333.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4969
+    }
-4970
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_227() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://333333333333.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-4994
+    }
-4995
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_228() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-west-2:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://111111111111.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://111111111111.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-5019
+    }
-5020
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_229() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:s3:us-east-1:333333333333:stream/testStream".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://111111111111.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://111111111111.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-5044
+    }
-5045
     /// {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_230() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)

↧ Expand context

             .account_id("".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Credentials-sourced account ID parameter is invalid [{UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=required, Region=us-east-1}]");
         assert_eq!(format!("{}", error), "Credentials-sourced account ID parameter is invalid")
-5061
+    }
-5062
     /// {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_231() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())

@@ -5339,5086 +5423,5174 @@

↥ Expand context

         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported [{UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported"
-5100
+        )
-5101
+    }
-5102
     /// {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_233() {

         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported [{UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}]");
         let endpoint = endpoint.expect("Expected valid endpoint: https://222222222222.ddb.us-east-1.api.aws");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported"
--
+        )
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://222222222222.ddb.us-east-1.api.aws")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-5124
+    }
-5125
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_234() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://222222222222.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://222222222222.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-5147
+    }
-5148
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_235() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)

↧ Expand context

             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: AccountIdEndpointMode is required but no AccountID was provided or able to be loaded [{UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}]");
         assert_eq!(
             format!("{}", error),
             "AccountIdEndpointMode is required but no AccountID was provided or able to be loaded"
-5166
+        )
-5167
+    }
-5168
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_236() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)

@@ -5481,5232 +5588,5344 @@

↥ Expand context

         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported [{UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported"
-5246
+        )
-5247
+    }
-5248
     /// {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_240() {

         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported [{UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}]");
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.api.aws");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported"
--
+        )
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://333333333333.ddb.us-east-1.api.aws")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-5270
+    }
-5271
     /// {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_241() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://333333333333.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://333333333333.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-5293
+    }
-5294
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_242() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://222222222222.ddb.us-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://222222222222.ddb.us-east-1.amazonaws.com")
                 .property("metricValues", vec!["O".to_string().into()])
                 .build()
         );
-5317
+    }
-5318
     /// {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=required, Region=us-east-1}
     #[test]
     fn test_243() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)

↧ Expand context

             .account_id_endpoint_mode("required".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: AccountIdEndpointMode is required but no AccountID was provided or able to be loaded [{UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=required, Region=us-east-1}]");
         assert_eq!(
             format!("{}", error),
             "AccountIdEndpointMode is required but no AccountID was provided or able to be loaded"
-5335
+        )
-5336
+    }
-5337
     /// {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_244() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(true)
             .account_id("111111111111".to_string())

@@ -5605,5361 +5668,5424 @@

↥ Expand context

         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported [{UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported"
-5375
+        )
-5376
+    }
-5377
     /// {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_246() {

         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported [{UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}]");
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition [{UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported"
             "Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition"
-5395
+        )
-5396
+    }
-5397
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_247() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())

↧ Expand context

             .account_id_endpoint_mode("required".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition [{UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition"
-5415
+        )
-5416
+    }
-5417
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_248() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())

@@ -5836,5592 +5899,5655 @@

↥ Expand context

         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported [{UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported"
-5606
+        )
-5607
+    }
-5608
     /// {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_257() {

         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("required".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported [{UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}]");
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition [{UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported"
             "Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition"
-5626
+        )
-5627
+    }
-5628
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_258() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())

↧ Expand context

             .account_id_endpoint_mode("required".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition [{UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition"
-5646
+        )
-5647
+    }
-5648
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_259() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())

@@ -5976,5732 +6039,5795 @@

↥ Expand context

         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported [{UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported"
-5746
+        )
-5747
+    }
-5748
     /// {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_264() {

         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("required".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported [{UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}]");
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition [{UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported"
             "Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition"
-5766
+        )
-5767
+    }
-5768
     /// {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_265() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])

↧ Expand context

             .account_id_endpoint_mode("required".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition [{UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}]");
         assert_eq!(
             format!("{}", error),
             "Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition"
-5786
+        )
-5787
+    }
-5788
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
     #[test]
     fn test_266() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())

@@ -7121,6877 +8125,8121 @@

↥ Expand context

         let endpoint = endpoint.expect("Expected valid endpoint: https://dynamodb.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.cn-north-1.amazonaws.com.cn")
                 .build()
         );
-6884
+    }
-6885
     /// {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=cn-north-1}
     #[test]
     fn test_315() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id_endpoint_mode("preferred".to_string())
             .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://dynamodb.cn-north-1.amazonaws.com.cn");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.cn-north-1.amazonaws.com.cn")
                 .build()
         );
-6905
+    }
-6906
     /// {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     /// {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_316() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb-fips.us-iso-east-1.api.aws.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-iso-east-1.api.aws.ic.gov")
                 .build()
         );
-+
+    }
-+
     /// {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_317() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb-fips.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-6949
+    }
-6950
     /// {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_318() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.api.aws.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.api.aws.ic.gov")
                 .build()
         );
-+
+    }
-+
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_317() {
     fn test_319() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-6993
+    }
-6994
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_318() {
     fn test_320() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7016
+    }
-7017
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_319() {
     fn test_321() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7040
+    }
-7041
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_320() {
     fn test_322() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7064
+    }
-7065
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_321() {
     fn test_323() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7088
+    }
-7089
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_322() {
     fn test_324() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-west-2:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7112
+    }
-7113
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_323() {
     fn test_325() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:s3:us-east-1:333333333333:stream/testStream".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7136
+    }
-7137
     /// {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_324() {
     fn test_326() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7158
+    }
-7159
     /// {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_327() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb-fips.us-iso-east-1.api.aws.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-iso-east-1.api.aws.ic.gov")
                 .build()
         );
-+
+    }
-+
     /// {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_325() {
     fn test_328() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb-fips.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7202
+    }
-7203
     /// {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_329() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.api.aws.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.api.aws.ic.gov")
                 .build()
         );
-+
+    }
-+
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_326() {
     fn test_330() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7246
+    }
-7247
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_327() {
     fn test_331() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7268
+    }
-7269
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_328() {
     fn test_332() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7290
+    }
-7291
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_329() {
     fn test_333() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7312
+    }
-7313
     /// {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_334() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb-fips.us-iso-east-1.api.aws.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-iso-east-1.api.aws.ic.gov")
                 .build()
         );
-+
+    }
-+
     /// {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_330() {
     fn test_335() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb-fips.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7356
+    }
-7357
     /// {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_336() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.api.aws.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.api.aws.ic.gov")
                 .build()
         );
-+
+    }
-+
     /// {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_331() {
     fn test_337() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7400
+    }
-7401
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_332() {
     fn test_338() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7423
+    }
-7424
     /// {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
     #[test]
     fn test_333() {
     fn test_339() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-iso-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://dynamodb.us-iso-east-1.c2s.ic.gov");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-iso-east-1.c2s.ic.gov")
                 .build()
         );
-7444
+    }
-7445
     /// {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_334() {
     fn test_340() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb-fips.us-gov-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-gov-east-1.api.aws")
                 .build()
         );
-7466
+    }
-7467
     /// {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_335() {
     fn test_341() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7488
+    }
-7489
     /// {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_336() {
     fn test_342() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.api.aws")
                 .build()
         );
-7510
+    }
-7511
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_337() {
     fn test_343() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7532
+    }
-7533
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_338() {
     fn test_344() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7555
+    }
-7556
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_339() {
     fn test_345() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7579
+    }
-7580
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_340() {
     fn test_346() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7603
+    }
-7604
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_341() {
     fn test_347() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7627
+    }
-7628
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_342() {
     fn test_348() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-west-2:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7651
+    }
-7652
     /// {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_343() {
     fn test_349() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("111111111111".to_string())
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .resource_arn_list(vec!["arn:aws:s3:us-east-1:333333333333:stream/testStream".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7675
+    }
-7676
     /// {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_344() {
     fn test_350() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id("".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7697
+    }
-7698
     /// {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_345() {
     fn test_351() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb-fips.us-gov-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-gov-east-1.api.aws")
                 .build()
         );
-7719
+    }
-7720
     /// {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_346() {
     fn test_352() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7741
+    }
-7742
     /// {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_347() {
     fn test_353() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.api.aws")
                 .build()
         );
-7763
+    }
-7764
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_348() {
     fn test_354() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7785
+    }
-7786
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_349() {
     fn test_355() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-west-2:222222222222:table/table_name".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7807
+    }
-7808
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_350() {
     fn test_356() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:s3:us-west-2:222222222222:stream/testStream".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7829
+    }
-7830
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_351() {
     fn test_357() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("".to_string())
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7851
+    }
-7852
     /// {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_352() {
     fn test_358() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb-fips.us-gov-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb-fips.us-gov-east-1.api.aws")
                 .build()
         );
-7873
+    }
-7874
     /// {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_353() {
     fn test_359() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(true)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7895
+    }
-7896
     /// {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_354() {
     fn test_360() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(true)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.api.aws")
                 .build()
         );
-7917
+    }
-7918
     /// {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_355() {
     fn test_361() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7939
+    }
-7940
     /// {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_356() {
     fn test_362() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .resource_arn("arn:aws:dynamodb:us-east-1:222222222222:table/table_name".to_string())
             .resource_arn_list(vec!["arn:aws:dynamodb:us-east-1:333333333333:table/table_name".to_string().into()])
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7962
+    }
-7963
     /// {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
     #[test]
     fn test_357() {
     fn test_363() {
         let params = crate::config::endpoint::Params::builder()
             .use_fips(false)
             .use_dual_stack(false)
             .account_id_endpoint_mode("preferred".to_string())
             .region("us-gov-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://dynamodb.us-gov-east-1.amazonaws.com");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://dynamodb.us-gov-east-1.amazonaws.com")
                 .build()
         );
-7983
+    }
-+
     /// {Endpoint=https://dynamodb.cn-north-1.api.amazonwebservices.com.cn, Region=cn-north-1}
     #[test]
     fn test_364() {
         let params = crate::config::endpoint::Params::builder()
             .endpoint("https://dynamodb.cn-north-1.api.amazonwebservices.com.cn".to_string())
             .region("cn-north-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html [{Endpoint=https://dynamodb.cn-north-1.api.amazonwebservices.com.cn, Region=cn-north-1}]");
         assert_eq!(format!("{}", error), "Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html")
-+
+    }
-+
     /// {Endpoint=https://dynamodb.us-gov-east-1.api.aws, Region=us-gov-east-1}
     #[test]
     fn test_365() {
         let params = crate::config::endpoint::Params::builder()
             .endpoint("https://dynamodb.us-gov-east-1.api.aws".to_string())
             .region("us-gov-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html [{Endpoint=https://dynamodb.us-gov-east-1.api.aws, Region=us-gov-east-1}]");
         assert_eq!(format!("{}", error), "Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html")
-+
+    }
-+
     /// {Endpoint=https://dynamodb.us-east-1.api.aws, Region=us-east-1}
     #[test]
     fn test_366() {
         let params = crate::config::endpoint::Params::builder()
             .endpoint("https://dynamodb.us-east-1.api.aws".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html [{Endpoint=https://dynamodb.us-east-1.api.aws, Region=us-east-1}]");
         assert_eq!(format!("{}", error), "Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html")
-+
+    }
-+
     /// {Endpoint=https://111111111111.ddb.us-east-1.api.aws, Region=us-east-1}
     #[test]
     fn test_367() {
         let params = crate::config::endpoint::Params::builder()
             .endpoint("https://111111111111.ddb.us-east-1.api.aws".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://111111111111.ddb.us-east-1.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://111111111111.ddb.us-east-1.api.aws")
                 .build()
         );
-+
+    }
-+
     /// {Endpoint=https://vpce-1a2b3c4d-5e6f.dynamodb.us-east-1.vpce.api.aws, Region=us-east-1}
     #[test]
     fn test_368() {
         let params = crate::config::endpoint::Params::builder()
             .endpoint("https://vpce-1a2b3c4d-5e6f.dynamodb.us-east-1.vpce.api.aws".to_string())
             .region("us-east-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let endpoint = endpoint.expect("Expected valid endpoint: https://vpce-1a2b3c4d-5e6f.dynamodb.us-east-1.vpce.api.aws");
         assert_eq!(
             endpoint,
             ::aws_smithy_types::endpoint::Endpoint::builder()
                 .url("https://vpce-1a2b3c4d-5e6f.dynamodb.us-east-1.vpce.api.aws")
                 .build()
         );
-+
+    }
-+
     /// {Endpoint=https://dynamodb.eu-west-1.api.aws, Region=eu-west-1}
     #[test]
     fn test_369() {
         let params = crate::config::endpoint::Params::builder()
             .endpoint("https://dynamodb.eu-west-1.api.aws".to_string())
             .region("eu-west-1".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html [{Endpoint=https://dynamodb.eu-west-1.api.aws, Region=eu-west-1}]");
         assert_eq!(format!("{}", error), "Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html")
-+
+    }
-+
     /// {Endpoint=https://dynamodb.us-west-2.api.aws, Region=us-west-2}
     #[test]
     fn test_370() {
         let params = crate::config::endpoint::Params::builder()
             .endpoint("https://dynamodb.us-west-2.api.aws".to_string())
             .region("us-west-2".to_string())
             .build()
             .expect("invalid params");
         let resolver = crate::config::endpoint::DefaultResolver::new();
         let endpoint = resolver.resolve_endpoint(&params);
         let error = endpoint.expect_err("expected error: Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html [{Endpoint=https://dynamodb.us-west-2.api.aws, Region=us-west-2}]");
         assert_eq!(format!("{}", error), "Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html")
-+
+    }
-8092
+}
-8093
 /// Endpoint resolver trait specific to Amazon DynamoDB
 pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
     /// Resolve an endpoint with the given parameters
     fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
-8098
     /// Convert this service-specific resolver into a `SharedEndpointResolver`
     ///
     /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.

↧ Expand context

     fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
     where
         Self: Sized + 'static,
-8105
+    {
         ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
-8107
+    }
-8108
+}
-8109
 #[derive(Debug)]
 struct DowncastParams<T>(T);
 impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
 where
     T: ResolveEndpoint,
-8115
+{
     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),

@@ -8136,8132 +8226,9110 @@

↥ Expand context

         // Furthermore, by using `std::mem::replace` with an empty `Identity`, we avoid
         // leaving the sensitive `Identity` inside `params` within `EndpointResolverParams`.
         let identity = params
             .get_property_mut::<::aws_smithy_runtime_api::client::identity::Identity>()
             .map(|id| {
                 std::mem::replace(
                     id,
                     ::aws_smithy_runtime_api::client::identity::Identity::new((), ::std::option::Option::None),
-8140
+                )
             });
         match (
             params.get_mut::<crate::config::endpoint::Params>(),
             identity
                 .as_ref()
                 .and_then(|id| id.property::<::aws_credential_types::attributes::AccountId>()),
         ) {
             (::std::option::Option::Some(concrete_params), ::std::option::Option::Some(account_id)) => {
                 concrete_params.account_id = ::std::option::Option::Some(account_id.as_str().to_string());
-8150
+            }
             (::std::option::Option::Some(_), ::std::option::Option::None) => {

                 // No account ID; nothing to do.
-8153
+            }
             (::std::option::Option::None, _) => {
                 return ::std::result::Result::Err("service-specific endpoint params was not present".into());
-8156
+            }
-8157
+        }
         ::std::result::Result::Ok(())
-8159
+    }
-8160
+}
-8161
 /// 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()
-+
+    }
-8173
+}
-8174
 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(),
             partition_resolver: &crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER,
             endpoint_cache: ::arc_swap::ArcSwap::from_pointee(None),
-8181
+        }
-8182
+    }
-8183
     fn resolve_endpoint(
         &self,
         params: &crate::config::endpoint::Params,
     #[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_dual_stack = &params.use_dual_stack;
         let use_fips = &params.use_fips;
         let endpoint = &params.endpoint;
         let account_id = &params.account_id;
         let account_id_endpoint_mode = &params.account_id_endpoint_mode;
         let resource_arn = &params.resource_arn;
         let resource_arn_list = &params.resource_arn_list;
-+
         let mut current_ref: i32 = 67;
         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("Invalid Configuration: FIPS and custom endpoint are not supported"
 .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)
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("Endpoint override is not supported for dual-stack endpoints. Please enable dual-stack functionality by enabling the configuration. For more details, see: https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html"
 .to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
                         },
 => {
                             let endpoint = params.endpoint.as_deref().unwrap_or_default();
                             ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url(endpoint.to_owned())
 .build())
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("Invalid Configuration: FIPS and local endpoint are not supported"
 .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 local endpoint are not supported"
 .to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
                         },
 => {
-+
                             ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url("http://localhost:8000"
 .to_string())
 .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4"
 .to_string(), 2)
 .put("signingName", "dynamodb")
 .put("signingRegion", "us-east-1")
-+
+)
 .build())
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported"
 .to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
                         },
 => {
                             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://dynamodb-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 })
 .build())
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("FIPS and DualStack are enabled, but this partition does not support one or both"
 .to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
                         },
 => {
                             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://dynamodb.");
 #[allow(clippy::needless_borrow)]
 out.push_str(&region.as_ref());
 out.push('.');
 #[allow(clippy::needless_borrow)]
 out.push_str(&partition_result.dns_suffix());
 out })
 .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://dynamodb-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 })
 .build())
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("FIPS is enabled but this partition does not support FIPS"
 .to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
                         },
 => {
                             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.");
 let parsed_arn_ssa_2 = context.parsed_arn_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
 out.push_str("https://");
 #[allow(clippy::needless_borrow)]
 out.push_str(&parsed_arn_ssa_2.account_id());
 out.push_str(".ddb.");
 #[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 })
 .property("metricValues", vec![::aws_smithy_types::Document::from("O"
 .to_string()),])
 .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.");
 let parsed_arn_ssa_1 = context.parsed_arn_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://");
 #[allow(clippy::needless_borrow)]
 out.push_str(&parsed_arn_ssa_1.account_id());
 out.push_str(".ddb.");
 #[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 })
 .property("metricValues", vec![::aws_smithy_types::Document::from("O"
 .to_string()),])
 .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(".ddb.");
 #[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 })
 .property("metricValues", vec![::aws_smithy_types::Document::from("O"
 .to_string()),])
 .build())
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("Credentials-sourced account ID parameter is invalid"
 .to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("AccountIdEndpointMode is required but no AccountID was provided or able to be loaded"
 .to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition"
 .to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
                         },
 => {
                             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://dynamodb.");
 #[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 })
 .build())
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("DualStack is enabled but this partition does not support DualStack"
 .to_string())) as ::aws_smithy_runtime_api::box_error::BoxError)
                         },
 => {
                             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.");
 let parsed_arn_ssa_2 = context.parsed_arn_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                             ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
 out.push_str("https://");
 #[allow(clippy::needless_borrow)]
 out.push_str(&parsed_arn_ssa_2.account_id());
 out.push_str(".ddb.");
 #[allow(clippy::needless_borrow)]
 out.push_str(&region.as_ref());
 out.push('.');
 #[allow(clippy::needless_borrow)]
 out.push_str(&partition_result.dns_suffix());
 out })
 .property("metricValues", vec![::aws_smithy_types::Document::from("O"
 .to_string()),])
 .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.");
 let parsed_arn_ssa_1 = context.parsed_arn_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://");
 #[allow(clippy::needless_borrow)]
 out.push_str(&parsed_arn_ssa_1.account_id());
 out.push_str(".ddb.");
 #[allow(clippy::needless_borrow)]
 out.push_str(&region.as_ref());
 out.push('.');
 #[allow(clippy::needless_borrow)]
 out.push_str(&partition_result.dns_suffix());
 out })
 .property("metricValues", vec![::aws_smithy_types::Document::from("O"
 .to_string()),])
 .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(".ddb.");
 #[allow(clippy::needless_borrow)]
 out.push_str(&region.as_ref());
 out.push('.');
 #[allow(clippy::needless_borrow)]
 out.push_str(&partition_result.dns_suffix());
 out })
 .property("metricValues", vec![::aws_smithy_types::Document::from("O"
 .to_string()),])
 .build())
                         },
 => {
-+
                             ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("Invalid Configuration: Missing Region"
 .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(),
 => endpoint.is_some(),
 => (use_fips) == (&true),
 => (|_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),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (region) == &mut Some(("local".to_string().into()))
                         })(&mut _diagnostic_collector),
 => (|_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.supports_fips()
                             } else {
                                 return false;
                             }) == (true)
                         })(&mut _diagnostic_collector),
 => (use_dual_stack) == (&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.supports_dual_stack()
                             } else {
                                 return false;
                             }) == (true)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_result = &context.partition_result;
                             let partition_resolver = &self.partition_resolver;
                             &mut Some(
                                 ({
                                     let mut out = String::new();
                                     out.push_str("https://dynamodb.");
                                     #[allow(clippy::needless_borrow)]
                                     out.push_str(&region.as_deref().unwrap_or_default());
                                     out.push('.');
                                     #[allow(clippy::needless_borrow)]
                                     out.push_str(&if let Some(inner) = partition_result {
                                         inner.dual_stack_dns_suffix()
                                     } else {
                                         return false;
                                     });
                                     out
-+
+                                }
                                 .into()),
                             ) == (endpoint)
                         })(&mut _diagnostic_collector),
 => account_id_endpoint_mode.is_some(),
 => (|_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")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (account_id_endpoint_mode) == &mut Some(("disabled".to_string().into()))
                         })(&mut _diagnostic_collector),
 => resource_arn.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let parsed_arn_ssa_2 = &mut context.parsed_arn_ssa_2;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *parsed_arn_ssa_2 = crate::endpoint_lib::arn::parse_arn(
                                     if let Some(param) = resource_arn { param } else { return false },
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 parsed_arn_ssa_2.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let parsed_arn_ssa_2 = &context.parsed_arn_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             &mut Some(
                                 (if let Some(inner) = parsed_arn_ssa_2 {
                                     inner.region()
                                 } else {
                                     return false;
-+
+                                }
                                 .into()),
                             ) == (region)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let parsed_arn_ssa_2 = &context.parsed_arn_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = parsed_arn_ssa_2 {
                                 inner.service()
                             } else {
                                 return false;
                             }) == ("dynamodb")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let parsed_arn_ssa_2 = &context.parsed_arn_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(inner) = parsed_arn_ssa_2 {
                                     inner.account_id()
                                 } else {
                                     return false;
                                 },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let parsed_arn_ssa_2 = &context.parsed_arn_ssa_2;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(inner) = parsed_arn_ssa_2 {
                                     inner.region()
                                 } else {
                                     return false;
                                 },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => resource_arn_list.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let first_arn = &mut context.first_arn;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *first_arn = if let Some(inner) = resource_arn_list {
                                     inner.first().map(|s| s.as_str())
                                 } else {
                                     return false;
                                 };
                                 first_arn.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let first_arn = &context.first_arn;
                             let parsed_arn_ssa_1 = &mut context.parsed_arn_ssa_1;
                             let partition_resolver = &self.partition_resolver;
-+
+                            {
                                 *parsed_arn_ssa_1 = crate::endpoint_lib::arn::parse_arn(
                                     if let Some(param) = first_arn { param } else { return false },
                                     _diagnostic_collector,
-+
+                                )
                                 .map(|inner| inner.into());
                                 parsed_arn_ssa_1.is_some()
-+
+                            }
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let parsed_arn_ssa_1 = &context.parsed_arn_ssa_1;
                             let partition_resolver = &self.partition_resolver;
                             &mut Some(
                                 (if let Some(inner) = parsed_arn_ssa_1 {
                                     inner.region()
                                 } else {
                                     return false;
-+
+                                }
                                 .into()),
                             ) == (region)
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let parsed_arn_ssa_1 = &context.parsed_arn_ssa_1;
                             let partition_resolver = &self.partition_resolver;
                             (if let Some(inner) = parsed_arn_ssa_1 {
                                 inner.service()
                             } else {
                                 return false;
                             }) == ("dynamodb")
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let parsed_arn_ssa_1 = &context.parsed_arn_ssa_1;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(inner) = parsed_arn_ssa_1 {
                                     inner.account_id()
                                 } else {
                                     return false;
                                 },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let parsed_arn_ssa_1 = &context.parsed_arn_ssa_1;
                             let partition_resolver = &self.partition_resolver;
                             crate::endpoint_lib::host::is_valid_host_label(
                                 if let Some(inner) = parsed_arn_ssa_1 {
                                     inner.region()
                                 } else {
                                     return false;
                                 },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => account_id.is_some(),
 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                             let partition_resolver = &self.partition_resolver;
                             (account_id_endpoint_mode) == &mut Some(("required".to_string().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) = account_id { param } else { return false },
                                 false,
                                 _diagnostic_collector,
-+
+                            )
                         })(&mut _diagnostic_collector),
 => (|_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-us-gov")
                         })(&mut _diagnostic_collector),
                         _ => unreachable!("Invalid condition index"),
                     };
                     current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };
-+
+                }
-+
+            }
-+
+        }
-8712
+    }
-8713
+}
-8714
 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))
     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)
-8730
+    }
-8731
+}
 const NODES: [crate::endpoint_lib::bdd_interpreter::BddNode; 67] = [
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: -1,
         high_ref: 1,
         low_ref: -1,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 8,
         high_ref: 100000003,
         low_ref: 100000004,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 6,
         high_ref: 100000002,
         low_ref: 2,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 6,
         high_ref: 100000002,
         low_ref: 100000004,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 3,
         high_ref: 3,
         low_ref: 4,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 2,
         high_ref: 100000001,
         low_ref: 5,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000008,
         low_ref: 100000009,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 9,
         high_ref: 7,
         low_ref: 100000009,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 7,
         high_ref: 8,
         low_ref: 100000010,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 28,
         high_ref: 100000011,
         low_ref: 100000012,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000008,
         low_ref: 10,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 9,
         high_ref: 11,
         low_ref: 10,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 6,
         high_ref: 9,
         low_ref: 12,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 6,
         high_ref: 100000010,
         low_ref: 100000013,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 5,
         high_ref: 13,
         low_ref: 14,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 4,
         high_ref: 100000005,
         low_ref: 15,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 3,
         high_ref: 16,
         low_ref: 100000025,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 6,
         high_ref: 100000006,
         low_ref: 100000007,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000018,
         low_ref: 100000020,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 27,
         high_ref: 100000016,
         low_ref: 100000017,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 25,
         high_ref: 20,
         low_ref: 19,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 100000015,
         low_ref: 21,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 22,
         low_ref: 21,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 22,
         high_ref: 23,
         low_ref: 21,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 24,
         low_ref: 21,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 20,
         high_ref: 25,
         low_ref: 21,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 19,
         high_ref: 26,
         low_ref: 21,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 18,
         high_ref: 27,
         low_ref: 21,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 17,
         high_ref: 100000014,
         low_ref: 28,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 29,
         low_ref: 28,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 30,
         low_ref: 28,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 31,
         low_ref: 28,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 32,
         low_ref: 28,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 33,
         low_ref: 28,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 11,
         high_ref: 19,
         low_ref: 34,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000019,
         low_ref: 100000020,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 10,
         high_ref: 35,
         low_ref: 36,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 9,
         high_ref: 37,
         low_ref: 100000020,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 7,
         high_ref: 38,
         low_ref: 100000021,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000018,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 27,
         high_ref: 100000024,
         low_ref: 100000017,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 25,
         high_ref: 41,
         low_ref: 40,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 24,
         high_ref: 100000023,
         low_ref: 42,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 23,
         high_ref: 43,
         low_ref: 42,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 22,
         high_ref: 44,
         low_ref: 42,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 21,
         high_ref: 45,
         low_ref: 42,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 20,
         high_ref: 46,
         low_ref: 42,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 19,
         high_ref: 47,
         low_ref: 42,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 18,
         high_ref: 48,
         low_ref: 42,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 17,
         high_ref: 100000022,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 16,
         high_ref: 50,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 15,
         high_ref: 51,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 14,
         high_ref: 52,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 13,
         high_ref: 53,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 12,
         high_ref: 54,
         low_ref: 49,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 11,
         high_ref: 40,
         low_ref: 55,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 26,
         high_ref: 100000019,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 10,
         high_ref: 56,
         low_ref: 57,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 9,
         high_ref: 58,
         low_ref: 100000011,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 6,
         high_ref: 39,
         low_ref: 59,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 4,
         high_ref: 18,
         low_ref: 60,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 3,
         high_ref: 61,
         low_ref: 100000025,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 2,
         high_ref: 17,
         low_ref: 62,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 1,
         high_ref: 6,
         low_ref: 63,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 2,
         high_ref: 100000001,
         low_ref: 4,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 1,
         high_ref: 65,
         low_ref: 100000025,
     },
     crate::endpoint_lib::bdd_interpreter::BddNode {
         condition_index: 0,
         high_ref: 64,
         low_ref: 66,
     },
 ];
 // 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) parsed_arn_ssa_2: Option<crate::endpoint_lib::arn::Arn<'a>>,
     pub(crate) first_arn: Option<&'a str>,
     pub(crate) parsed_arn_ssa_1: Option<crate::endpoint_lib::arn::Arn<'a>>,
     // Sometimes none of the members reference the lifetime, this makes it still valid
     phantom: std::marker::PhantomData<&'a ()>,
-+
+}
-9081
 #[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, 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,
     /// 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.

↧ Expand context

     pub(crate) use_fips: bool,
     /// Override the endpoint used to send this request
     pub(crate) endpoint: ::std::option::Option<::std::string::String>,
     /// The AWS AccountId used for the request.
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     /// The AccountId Endpoint Mode.
     pub(crate) account_id_endpoint_mode: ::std::option::Option<::std::string::String>,
     /// ResourceArn containing arn of resource
     pub(crate) resource_arn: ::std::option::Option<::std::string::String>,
     /// ResourceArnList containing list of resource arns
     pub(crate) resource_arn_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-9102
+}
 impl Params {
     /// Create a builder for [`Params`]
     pub fn builder() -> crate::config::endpoint::ParamsBuilder {
         crate::config::endpoint::ParamsBuilder::default()
-9107
+    }
     /// The AWS region used to dispatch the request.
     pub fn region(&self) -> ::std::option::Option<&str> {
         self.region.as_deref()

@@ -8443,9327 +8474,0 @@

↥ Expand context

-9327
+}
-9328
 impl InvalidParams {
     #[allow(dead_code)]
     fn missing(field: &'static str) -> Self {
         Self {
             field: field.into(),
             kind: InvalidParamsErrorKind::MissingField,
-9335
+        }
-9336
+    }
-9337
     #[allow(dead_code)]
     fn invalid_value(field: &'static str, message: &'static str) -> Self {
         Self {
             field: field.into(),
             kind: InvalidParamsErrorKind::InvalidValue { message },
-9343
+        }
-9344
+    }
-9345
+}
-9346

 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),
-9352
+        }
-9353
+    }
-9354
+}
-9355
 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-dynamodb"
 version = "0.0.0-local"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
 description = "AWS SDK for Amazon DynamoDB"
 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#awsJson1_0"
 [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]

         };
         if let Err(err) = Self::validate_config(&handle) {
             panic!("Invalid client configuration: {err}");
-116
+        }
         Self {
             handle: ::std::sync::Arc::new(handle),
-119
+        }
-120
+    }
-121
     /// Returns the client's configuration.
     pub fn config(&self) -> &crate::Config {
         &self.handle.conf
-125
+    }
-126
     fn validate_config(handle: &Handle) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let mut cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         handle
             .runtime_plugins
             .apply_client_configuration(&mut cfg)?
             .validate_base_client_config(&cfg)?;

         Ok(())
-134
+    }
-135
+}
-136
 ///
 /// Waiter functions for the client.
 ///
 /// Import this trait to get `wait_until` methods on the client.
 ///
 pub trait Waiters {
     /// Wait for `contributor_insights_enabled`
     fn wait_until_contributor_insights_enabled(&self) -> crate::waiters::contributor_insights_enabled::ContributorInsightsEnabledFluentBuilder;
     /// Wait for `export_completed`
     fn wait_until_export_completed(&self) -> crate::waiters::export_completed::ExportCompletedFluentBuilder;
     /// Wait for `import_completed`
     fn wait_until_import_completed(&self) -> crate::waiters::import_completed::ImportCompletedFluentBuilder;
     /// Wait for `kinesis_streaming_destination_active`
     fn wait_until_kinesis_streaming_destination_active(
         &self,
     ) -> crate::waiters::kinesis_streaming_destination_active::KinesisStreamingDestinationActiveFluentBuilder;
     /// Wait for `table_exists`
     fn wait_until_table_exists(&self) -> crate::waiters::table_exists::TableExistsFluentBuilder;
     /// Wait for `table_not_exists`
     fn wait_until_table_not_exists(&self) -> crate::waiters::table_not_exists::TableNotExistsFluentBuilder;
-157
+}
 impl Waiters for Client {
     fn wait_until_contributor_insights_enabled(&self) -> crate::waiters::contributor_insights_enabled::ContributorInsightsEnabledFluentBuilder {
         crate::waiters::contributor_insights_enabled::ContributorInsightsEnabledFluentBuilder::new(self.handle.clone())
-+
+    }
     fn wait_until_export_completed(&self) -> crate::waiters::export_completed::ExportCompletedFluentBuilder {
         crate::waiters::export_completed::ExportCompletedFluentBuilder::new(self.handle.clone())
-+
+    }
     fn wait_until_import_completed(&self) -> crate::waiters::import_completed::ImportCompletedFluentBuilder {
         crate::waiters::import_completed::ImportCompletedFluentBuilder::new(self.handle.clone())
-+
+    }
     fn wait_until_kinesis_streaming_destination_active(
         &self,
     ) -> crate::waiters::kinesis_streaming_destination_active::KinesisStreamingDestinationActiveFluentBuilder {
         crate::waiters::kinesis_streaming_destination_active::KinesisStreamingDestinationActiveFluentBuilder::new(self.handle.clone())
-+
+    }
     fn wait_until_table_exists(&self) -> crate::waiters::table_exists::TableExistsFluentBuilder {
         crate::waiters::table_exists::TableExistsFluentBuilder::new(self.handle.clone())
-175
+    }
     fn wait_until_table_not_exists(&self) -> crate::waiters::table_not_exists::TableNotExistsFluentBuilder {
         crate::waiters::table_not_exists::TableNotExistsFluentBuilder::new(self.handle.clone())
-178
+    }
-179
+}
-180
 impl Client {
     /// Creates a new client from an [SDK Config](::aws_types::sdk_config::SdkConfig).

AWS SDK

Files changed:

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

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/client.rs

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/client/create_table.rs

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/client/export_table_to_point_in_time.rs

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/client/update_item.rs

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/client/update_table.rs

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

     ///
     /// # Panics
     ///
     /// - This method will panic if the `sdk_config` is missing an async sleep implementation. If you experience this panic, set
     ///   the `sleep_impl` on the Config passed into this function to fix it.
     /// - This method will panic if the `sdk_config` is missing an HTTP connector. If you experience this panic, set the
     ///   `http_connector` on the Config passed into this function to fix it.
     /// - This method will panic if no `BehaviorVersion` is provided. If you experience this panic, set `behavior_version` on the Config or enable the `behavior-version-latest` Cargo feature.
     #[track_caller]
     pub fn new(sdk_config: &::aws_types::sdk_config::SdkConfig) -> Self {
         Self::from_conf(sdk_config.into())
-194
+    }
-195
+}
-196
 mod batch_execute_statement;
-198
 mod batch_get_item;
-200
 mod batch_write_item;
-202

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 impl super::Client {
     /// Constructs a fluent builder for the [`CreateTable`](crate::operation::create_table::builders::CreateTableFluentBuilder) operation.
     ///
     /// - The fluent builder is configurable:
     ///   - [`attribute_definitions(AttributeDefinition)`](crate::operation::create_table::builders::CreateTableFluentBuilder::attribute_definitions) / [`set_attribute_definitions(Option<Vec::<AttributeDefinition>>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_attribute_definitions):<br>required: **true**<br><p>An array of attributes that describe the key schema for the table and indexes.</p><br>
     ///   - [`attribute_definitions(AttributeDefinition)`](crate::operation::create_table::builders::CreateTableFluentBuilder::attribute_definitions) / [`set_attribute_definitions(Option<Vec::<AttributeDefinition>>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_attribute_definitions):<br>required: **false**<br><p>An array of attributes that describe the key schema for the table and indexes.</p><br>
     ///   - [`table_name(impl Into<String>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::table_name) / [`set_table_name(Option<String>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_table_name):<br>required: **true**<br><p>The name of the table to create. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p><br>
     ///   - [`key_schema(KeySchemaElement)`](crate::operation::create_table::builders::CreateTableFluentBuilder::key_schema) / [`set_key_schema(Option<Vec::<KeySchemaElement>>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_key_schema):<br>required: **true**<br><p>Specifies the attributes that make up the primary key for a table or an index. The attributes in <code>KeySchema</code> must also be defined in the <code>AttributeDefinitions</code> array. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html">Data Model</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> <p>Each <code>KeySchemaElement</code> in the array is composed of:</p> <ul>  <li>   <p><code>AttributeName</code> - The name of this key attribute.</p></li>  <li>   <p><code>KeyType</code> - The role that the key attribute will assume:</p>   <ul>    <li>     <p><code>HASH</code> - partition key</p></li>    <li>     <p><code>RANGE</code> - sort key</p></li>   </ul></li> </ul><note>  <p>The partition key of an item is also known as its <i>hash attribute</i>. The term "hash attribute" derives from the DynamoDB usage of an internal hash function to evenly distribute data items across partitions, based on their partition key values.</p>  <p>The sort key of an item is also known as its <i>range attribute</i>. The term "range attribute" derives from the way DynamoDB stores items with the same partition key physically close together, in sorted order by the sort key value.</p> </note> <p>For a simple primary key (partition key), you must provide exactly one element with a <code>KeyType</code> of <code>HASH</code>.</p> <p>For a composite primary key (partition key and sort key), you must provide exactly two elements, in this order: The first element must have a <code>KeyType</code> of <code>HASH</code>, and the second element must have a <code>KeyType</code> of <code>RANGE</code>.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#WorkingWithTables.primary.key">Working with Tables</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`key_schema(KeySchemaElement)`](crate::operation::create_table::builders::CreateTableFluentBuilder::key_schema) / [`set_key_schema(Option<Vec::<KeySchemaElement>>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_key_schema):<br>required: **false**<br><p>Specifies the attributes that make up the primary key for a table or an index. The attributes in <code>KeySchema</code> must also be defined in the <code>AttributeDefinitions</code> array. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html">Data Model</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> <p>Each <code>KeySchemaElement</code> in the array is composed of:</p> <ul>  <li>   <p><code>AttributeName</code> - The name of this key attribute.</p></li>  <li>   <p><code>KeyType</code> - The role that the key attribute will assume:</p>   <ul>    <li>     <p><code>HASH</code> - partition key</p></li>    <li>     <p><code>RANGE</code> - sort key</p></li>   </ul></li> </ul><note>  <p>The partition key of an item is also known as its <i>hash attribute</i>. The term "hash attribute" derives from the DynamoDB usage of an internal hash function to evenly distribute data items across partitions, based on their partition key values.</p>  <p>The sort key of an item is also known as its <i>range attribute</i>. The term "range attribute" derives from the way DynamoDB stores items with the same partition key physically close together, in sorted order by the sort key value.</p> </note> <p>For a simple primary key (partition key), you must provide exactly one element with a <code>KeyType</code> of <code>HASH</code>.</p> <p>For a composite primary key (partition key and sort key), you must provide exactly two elements, in this order: The first element must have a <code>KeyType</code> of <code>HASH</code>, and the second element must have a <code>KeyType</code> of <code>RANGE</code>.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#WorkingWithTables.primary.key">Working with Tables</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`local_secondary_indexes(LocalSecondaryIndex)`](crate::operation::create_table::builders::CreateTableFluentBuilder::local_secondary_indexes) / [`set_local_secondary_indexes(Option<Vec::<LocalSecondaryIndex>>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_local_secondary_indexes):<br>required: **false**<br><p>One or more local secondary indexes (the maximum is 5) to be created on the table. Each index is scoped to a given partition key value. There is a 10 GB size limit per partition key value; otherwise, the size of a local secondary index is unconstrained.</p> <p>Each local secondary index in the array includes the following:</p> <ul>  <li>   <p><code>IndexName</code> - The name of the local secondary index. Must be unique only for this table.</p>   <p></p></li>  <li>   <p><code>KeySchema</code> - Specifies the key schema for the local secondary index. The key schema must begin with the same partition key as the table.</p></li>  <li>   <p><code>Projection</code> - Specifies attributes that are copied (projected) from the table into the index. These are in addition to the primary key attributes and index key attributes, which are automatically projected. Each attribute specification is composed of:</p>   <ul>    <li>     <p><code>ProjectionType</code> - One of the following:</p>     <ul>      <li>       <p><code>KEYS_ONLY</code> - Only the index and primary keys are projected into the index.</p></li>      <li>       <p><code>INCLUDE</code> - Only the specified table attributes are projected into the index. The list of projected attributes is in <code>NonKeyAttributes</code>.</p></li>      <li>       <p><code>ALL</code> - All of the table attributes are projected into the index.</p></li>     </ul></li>    <li>     <p><code>NonKeyAttributes</code> - A list of one or more non-key attribute names that are projected into the secondary index. The total count of attributes provided in <code>NonKeyAttributes</code>, summed across all of the secondary indexes, must not exceed 100. If you project the same attribute into two different indexes, this counts as two distinct attributes when determining the total. This limit only applies when you specify the ProjectionType of <code>INCLUDE</code>. You still can specify the ProjectionType of <code>ALL</code> to project all attributes from the source table, even if the table has more than 100 attributes.</p></li>   </ul></li> </ul><br>
     ///   - [`global_secondary_indexes(GlobalSecondaryIndex)`](crate::operation::create_table::builders::CreateTableFluentBuilder::global_secondary_indexes) / [`set_global_secondary_indexes(Option<Vec::<GlobalSecondaryIndex>>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_global_secondary_indexes):<br>required: **false**<br><p>One or more global secondary indexes (the maximum is 20) to be created on the table. Each global secondary index in the array includes the following:</p> <ul>  <li>   <p><code>IndexName</code> - The name of the global secondary index. Must be unique only for this table.</p>   <p></p></li>  <li>   <p><code>KeySchema</code> - Specifies the key schema for the global secondary index.</p></li>  <li>   <p><code>Projection</code> - Specifies attributes that are copied (projected) from the table into the index. These are in addition to the primary key attributes and index key attributes, which are automatically projected. Each attribute specification is composed of:</p>   <ul>    <li>     <p><code>ProjectionType</code> - One of the following:</p>     <ul>      <li>       <p><code>KEYS_ONLY</code> - Only the index and primary keys are projected into the index.</p></li>      <li>       <p><code>INCLUDE</code> - Only the specified table attributes are projected into the index. The list of projected attributes is in <code>NonKeyAttributes</code>.</p></li>      <li>       <p><code>ALL</code> - All of the table attributes are projected into the index.</p></li>     </ul></li>    <li>     <p><code>NonKeyAttributes</code> - A list of one or more non-key attribute names that are projected into the secondary index. The total count of attributes provided in <code>NonKeyAttributes</code>, summed across all of the secondary indexes, must not exceed 100. If you project the same attribute into two different indexes, this counts as two distinct attributes when determining the total. This limit only applies when you specify the ProjectionType of <code>INCLUDE</code>. You still can specify the ProjectionType of <code>ALL</code> to project all attributes from the source table, even if the table has more than 100 attributes.</p></li>   </ul></li>  <li>   <p><code>ProvisionedThroughput</code> - The provisioned throughput settings for the global secondary index, consisting of read and write capacity units.</p></li> </ul><br>
     ///   - [`global_secondary_indexes(GlobalSecondaryIndex)`](crate::operation::create_table::builders::CreateTableFluentBuilder::global_secondary_indexes) / [`set_global_secondary_indexes(Option<Vec::<GlobalSecondaryIndex>>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_global_secondary_indexes):<br>required: **false**<br><p>One or more global secondary indexes (the maximum is 20) to be created on the table. Each global secondary index in the array includes the following:</p> <ul>  <li>   <p><code>IndexName</code> - The name of the global secondary index. Must be unique only for this table.</p>   <p></p></li>  <li>   <p><code>KeySchema</code> - Specifies the key schema for the global secondary index. Each global secondary index supports up to 4 partition keys and up to 4 sort keys.</p></li>  <li>   <p><code>Projection</code> - Specifies attributes that are copied (projected) from the table into the index. These are in addition to the primary key attributes and index key attributes, which are automatically projected. Each attribute specification is composed of:</p>   <ul>    <li>     <p><code>ProjectionType</code> - One of the following:</p>     <ul>      <li>       <p><code>KEYS_ONLY</code> - Only the index and primary keys are projected into the index.</p></li>      <li>       <p><code>INCLUDE</code> - Only the specified table attributes are projected into the index. The list of projected attributes is in <code>NonKeyAttributes</code>.</p></li>      <li>       <p><code>ALL</code> - All of the table attributes are projected into the index.</p></li>     </ul></li>    <li>     <p><code>NonKeyAttributes</code> - A list of one or more non-key attribute names that are projected into the secondary index. The total count of attributes provided in <code>NonKeyAttributes</code>, summed across all of the secondary indexes, must not exceed 100. If you project the same attribute into two different indexes, this counts as two distinct attributes when determining the total. This limit only applies when you specify the ProjectionType of <code>INCLUDE</code>. You still can specify the ProjectionType of <code>ALL</code> to project all attributes from the source table, even if the table has more than 100 attributes.</p></li>   </ul></li>  <li>   <p><code>ProvisionedThroughput</code> - The provisioned throughput settings for the global secondary index, consisting of read and write capacity units.</p></li> </ul><br>
     ///   - [`billing_mode(BillingMode)`](crate::operation::create_table::builders::CreateTableFluentBuilder::billing_mode) / [`set_billing_mode(Option<BillingMode>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_billing_mode):<br>required: **false**<br><p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p> <ul>  <li>   <p><code>PAY_PER_REQUEST</code> - We recommend using <code>PAY_PER_REQUEST</code> for most DynamoDB workloads. <code>PAY_PER_REQUEST</code> sets the billing mode to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/on-demand-capacity-mode.html">On-demand capacity mode</a>.</p></li>  <li>   <p><code>PROVISIONED</code> - We recommend using <code>PROVISIONED</code> for steady workloads with predictable growth where capacity requirements can be reliably forecasted. <code>PROVISIONED</code> sets the billing mode to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/provisioned-capacity-mode.html">Provisioned capacity mode</a>.</p></li> </ul><br>
     ///   - [`provisioned_throughput(ProvisionedThroughput)`](crate::operation::create_table::builders::CreateTableFluentBuilder::provisioned_throughput) / [`set_provisioned_throughput(Option<ProvisionedThroughput>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_provisioned_throughput):<br>required: **false**<br><p>Represents the provisioned throughput settings for a specified table or index. The settings can be modified using the <code>UpdateTable</code> operation.</p> <p>If you set BillingMode as <code>PROVISIONED</code>, you must specify this property. If you set BillingMode as <code>PAY_PER_REQUEST</code>, you cannot specify this property.</p> <p>For current minimum and maximum provisioned throughput values, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Service, Account, and Table Quotas</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`stream_specification(StreamSpecification)`](crate::operation::create_table::builders::CreateTableFluentBuilder::stream_specification) / [`set_stream_specification(Option<StreamSpecification>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_stream_specification):<br>required: **false**<br><p>The settings for DynamoDB Streams on the table. These settings consist of:</p> <ul>  <li>   <p><code>StreamEnabled</code> - Indicates whether DynamoDB Streams is to be enabled (true) or disabled (false).</p></li>  <li>   <p><code>StreamViewType</code> - When an item in the table is modified, <code>StreamViewType</code> determines what information is written to the table's stream. Valid values for <code>StreamViewType</code> are:</p>   <ul>    <li>     <p><code>KEYS_ONLY</code> - Only the key attributes of the modified item are written to the stream.</p></li>    <li>     <p><code>NEW_IMAGE</code> - The entire item, as it appears after it was modified, is written to the stream.</p></li>    <li>     <p><code>OLD_IMAGE</code> - The entire item, as it appeared before it was modified, is written to the stream.</p></li>    <li>     <p><code>NEW_AND_OLD_IMAGES</code> - Both the new and the old item images of the item are written to the stream.</p></li>   </ul></li> </ul><br>
     ///   - [`sse_specification(SseSpecification)`](crate::operation::create_table::builders::CreateTableFluentBuilder::sse_specification) / [`set_sse_specification(Option<SseSpecification>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_sse_specification):<br>required: **false**<br><p>Represents the settings used to enable server-side encryption.</p><br>
     ///   - [`tags(Tag)`](crate::operation::create_table::builders::CreateTableFluentBuilder::tags) / [`set_tags(Option<Vec::<Tag>>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_tags):<br>required: **false**<br><p>A list of key-value pairs to label the table. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging for DynamoDB</a>.</p><br>
     ///   - [`table_class(TableClass)`](crate::operation::create_table::builders::CreateTableFluentBuilder::table_class) / [`set_table_class(Option<TableClass>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_table_class):<br>required: **false**<br><p>The table class of the new table. Valid values are <code>STANDARD</code> and <code>STANDARD_INFREQUENT_ACCESS</code>.</p><br>
     ///   - [`deletion_protection_enabled(bool)`](crate::operation::create_table::builders::CreateTableFluentBuilder::deletion_protection_enabled) / [`set_deletion_protection_enabled(Option<bool>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_deletion_protection_enabled):<br>required: **false**<br><p>Indicates whether deletion protection is to be enabled (true) or disabled (false) on the table.</p><br>
     ///   - [`warm_throughput(WarmThroughput)`](crate::operation::create_table::builders::CreateTableFluentBuilder::warm_throughput) / [`set_warm_throughput(Option<WarmThroughput>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_warm_throughput):<br>required: **false**<br><p>Represents the warm throughput (in read units per second and write units per second) for creating a table.</p><br>
     ///   - [`resource_policy(impl Into<String>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::resource_policy) / [`set_resource_policy(Option<String>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_resource_policy):<br>required: **false**<br><p>An Amazon Web Services resource-based policy document in JSON format that will be attached to the table.</p> <p>When you attach a resource-based policy while creating a table, the policy application is <i>strongly consistent</i>.</p> <p>The maximum size supported for a resource-based policy document is 20 KB. DynamoDB counts whitespaces when calculating the size of a policy against this limit. For a full list of all considerations that apply for resource-based policies, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-considerations.html">Resource-based policy considerations</a>.</p><note>  <p>You need to specify the <code>CreateTable</code> and <code>PutResourcePolicy</code> IAM actions for authorizing a user to create a table with a resource-based policy.</p> </note><br>
     ///   - [`on_demand_throughput(OnDemandThroughput)`](crate::operation::create_table::builders::CreateTableFluentBuilder::on_demand_throughput) / [`set_on_demand_throughput(Option<OnDemandThroughput>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_on_demand_throughput):<br>required: **false**<br><p>Sets the maximum number of read and write units for the specified table in on-demand capacity mode. If you use this parameter, you must specify <code>MaxReadRequestUnits</code>, <code>MaxWriteRequestUnits</code>, or both.</p><br>
     ///   - [`global_table_source_arn(impl Into<String>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::global_table_source_arn) / [`set_global_table_source_arn(Option<String>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_global_table_source_arn):<br>required: **false**<br><p>The Amazon Resource Name (ARN) of the source table used for the creation of a multi-account global table.</p><br>
     ///   - [`global_table_settings_replication_mode(GlobalTableSettingsReplicationMode)`](crate::operation::create_table::builders::CreateTableFluentBuilder::global_table_settings_replication_mode) / [`set_global_table_settings_replication_mode(Option<GlobalTableSettingsReplicationMode>)`](crate::operation::create_table::builders::CreateTableFluentBuilder::set_global_table_settings_replication_mode):<br>required: **false**<br><p>Controls the settings synchronization mode for the global table. For multi-account global tables, this parameter is required and the only supported value is ENABLED. For same-account global tables, this parameter is set to ENABLED_WITH_OVERRIDES.</p><br>
     /// - On success, responds with [`CreateTableOutput`](crate::operation::create_table::CreateTableOutput) with field(s):
     ///   - [`table_description(Option<TableDescription>)`](crate::operation::create_table::CreateTableOutput::table_description): <p>Represents the properties of the table.</p>
     /// - On failure, responds with [`SdkError<CreateTableError>`](crate::operation::create_table::CreateTableError)
     pub fn create_table(&self) -> crate::operation::create_table::builders::CreateTableFluentBuilder {
         crate::operation::create_table::builders::CreateTableFluentBuilder::new(self.handle.clone())
-28
+    }
-29
+}

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 impl super::Client {
     /// Constructs a fluent builder for the [`ExportTableToPointInTime`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder) operation.
     ///
     /// - The fluent builder is configurable:
     ///   - [`table_arn(impl Into<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::table_arn) / [`set_table_arn(Option<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_table_arn):<br>required: **true**<br><p>The Amazon Resource Name (ARN) associated with the table to export.</p><br>
     ///   - [`export_time(DateTime)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::export_time) / [`set_export_time(Option<DateTime>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_export_time):<br>required: **false**<br><p>Time in the past from which to export table data, counted in seconds from the start of the Unix epoch. The table export will be a snapshot of the table's state at this point in time.</p><br>
     ///   - [`client_token(impl Into<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::client_token) / [`set_client_token(Option<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_client_token):<br>required: **false**<br><p>Providing a <code>ClientToken</code> makes the call to <code>ExportTableToPointInTimeInput</code> idempotent, meaning that multiple identical calls have the same effect as one single call.</p> <p>A client token is valid for 8 hours after the first request that uses it is completed. After 8 hours, any request with the same client token is treated as a new request. Do not resubmit the same request with the same client token for more than 8 hours, or the result might not be idempotent.</p> <p>If you submit a request with the same client token but a change in other parameters within the 8-hour idempotency window, DynamoDB returns an <code>ImportConflictException</code>.</p><br>
     ///   - [`client_token(impl Into<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::client_token) / [`set_client_token(Option<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_client_token):<br>required: **false**<br><p>Providing a <code>ClientToken</code> makes the call to <code>ExportTableToPointInTimeInput</code> idempotent, meaning that multiple identical calls have the same effect as one single call.</p> <p>A client token is valid for 8 hours after the first request that uses it is completed. After 8 hours, any request with the same client token is treated as a new request. Do not resubmit the same request with the same client token for more than 8 hours, or the result might not be idempotent.</p> <p>If you submit a request with the same client token but a change in other parameters within the 8-hour idempotency window, DynamoDB returns an <code>ExportConflictException</code>.</p><br>
     ///   - [`s3_bucket(impl Into<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::s3_bucket) / [`set_s3_bucket(Option<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_s3_bucket):<br>required: **true**<br><p>The name of the Amazon S3 bucket to export the snapshot to.</p><br>
     ///   - [`s3_bucket_owner(impl Into<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::s3_bucket_owner) / [`set_s3_bucket_owner(Option<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_s3_bucket_owner):<br>required: **false**<br><p>The ID of the Amazon Web Services account that owns the bucket the export will be stored in.</p><note>  <p>S3BucketOwner is a required parameter when exporting to a S3 bucket in another account.</p> </note><br>
     ///   - [`s3_prefix(impl Into<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::s3_prefix) / [`set_s3_prefix(Option<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_s3_prefix):<br>required: **false**<br><p>The Amazon S3 bucket prefix to use as the file name and path of the exported snapshot.</p><br>
     ///   - [`s3_sse_algorithm(S3SseAlgorithm)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::s3_sse_algorithm) / [`set_s3_sse_algorithm(Option<S3SseAlgorithm>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_s3_sse_algorithm):<br>required: **false**<br><p>Type of encryption used on the bucket where export data will be stored. Valid values for <code>S3SseAlgorithm</code> are:</p> <ul>  <li>   <p><code>AES256</code> - server-side encryption with Amazon S3 managed keys</p></li>  <li>   <p><code>KMS</code> - server-side encryption with KMS managed keys</p></li> </ul><br>
     ///   - [`s3_sse_kms_key_id(impl Into<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::s3_sse_kms_key_id) / [`set_s3_sse_kms_key_id(Option<String>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_s3_sse_kms_key_id):<br>required: **false**<br><p>The ID of the KMS managed key used to encrypt the S3 bucket where export data will be stored (if applicable).</p><br>
     ///   - [`export_format(ExportFormat)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::export_format) / [`set_export_format(Option<ExportFormat>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_export_format):<br>required: **false**<br><p>The format for the exported data. Valid values for <code>ExportFormat</code> are <code>DYNAMODB_JSON</code> or <code>ION</code>.</p><br>
     ///   - [`export_type(ExportType)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::export_type) / [`set_export_type(Option<ExportType>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_export_type):<br>required: **false**<br><p>Choice of whether to execute as a full export or incremental export. Valid values are FULL_EXPORT or INCREMENTAL_EXPORT. The default value is FULL_EXPORT. If INCREMENTAL_EXPORT is provided, the IncrementalExportSpecification must also be used.</p><br>
     ///   - [`incremental_export_specification(IncrementalExportSpecification)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::incremental_export_specification) / [`set_incremental_export_specification(Option<IncrementalExportSpecification>)`](crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::set_incremental_export_specification):<br>required: **false**<br><p>Optional object containing the parameters specific to an incremental export.</p><br>
     /// - On success, responds with [`ExportTableToPointInTimeOutput`](crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeOutput) with field(s):
     ///   - [`export_description(Option<ExportDescription>)`](crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeOutput::export_description): <p>Contains a description of the table export.</p>

     /// - On failure, responds with [`SdkError<ExportTableToPointInTimeError>`](crate::operation::export_table_to_point_in_time::ExportTableToPointInTimeError)
     pub fn export_table_to_point_in_time(&self) -> crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder {
         crate::operation::export_table_to_point_in_time::builders::ExportTableToPointInTimeFluentBuilder::new(self.handle.clone())
-22
+    }
-23
+}

     ///
     /// - The fluent builder is configurable:
     ///   - [`table_name(impl Into<String>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::table_name) / [`set_table_name(Option<String>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_table_name):<br>required: **true**<br><p>The name of the table containing the item to update. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p><br>
     ///   - [`key(impl Into<String>, AttributeValue)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::key) / [`set_key(Option<HashMap::<String, AttributeValue>>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_key):<br>required: **true**<br><p>The primary key of the item to be updated. Each element consists of an attribute name and a value for that attribute.</p> <p>For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key.</p><br>
     ///   - [`attribute_updates(impl Into<String>, AttributeValueUpdate)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::attribute_updates) / [`set_attribute_updates(Option<HashMap::<String, AttributeValueUpdate>>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_attribute_updates):<br>required: **false**<br><p>This is a legacy parameter. Use <code>UpdateExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributeUpdates.html">AttributeUpdates</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`expected(impl Into<String>, ExpectedAttributeValue)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::expected) / [`set_expected(Option<HashMap::<String, ExpectedAttributeValue>>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_expected):<br>required: **false**<br><p>This is a legacy parameter. Use <code>ConditionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.Expected.html">Expected</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`conditional_operator(ConditionalOperator)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::conditional_operator) / [`set_conditional_operator(Option<ConditionalOperator>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_conditional_operator):<br>required: **false**<br><p>This is a legacy parameter. Use <code>ConditionExpression</code> instead. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html">ConditionalOperator</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`return_values(ReturnValue)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::return_values) / [`set_return_values(Option<ReturnValue>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_return_values):<br>required: **false**<br><p>Use <code>ReturnValues</code> if you want to get the item attributes as they appear before or after they are successfully updated. For <code>UpdateItem</code>, the valid values are:</p> <ul>  <li>   <p><code>NONE</code> - If <code>ReturnValues</code> is not specified, or if its value is <code>NONE</code>, then nothing is returned. (This setting is the default for <code>ReturnValues</code>.)</p></li>  <li>   <p><code>ALL_OLD</code> - Returns all of the attributes of the item, as they appeared before the UpdateItem operation.</p></li>  <li>   <p><code>UPDATED_OLD</code> - Returns only the updated attributes, as they appeared before the UpdateItem operation.</p></li>  <li>   <p><code>ALL_NEW</code> - Returns all of the attributes of the item, as they appear after the UpdateItem operation.</p></li>  <li>   <p><code>UPDATED_NEW</code> - Returns only the updated attributes, as they appear after the UpdateItem operation.</p></li> </ul> <p>There is no additional cost associated with requesting a return value aside from the small network and processing overhead of receiving a larger response. No read capacity units are consumed.</p> <p>The values returned are strongly consistent.</p><br>
     ///   - [`return_consumed_capacity(ReturnConsumedCapacity)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::return_consumed_capacity) / [`set_return_consumed_capacity(Option<ReturnConsumedCapacity>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_return_consumed_capacity):<br>required: **false**<br><p>Determines the level of detail about either provisioned or on-demand throughput consumption that is returned in the response:</p> <ul>  <li>   <p><code>INDEXES</code> - The response includes the aggregate <code>ConsumedCapacity</code> for the operation, together with <code>ConsumedCapacity</code> for each table and secondary index that was accessed.</p>   <p>Note that some operations, such as <code>GetItem</code> and <code>BatchGetItem</code>, do not access any indexes at all. In these cases, specifying <code>INDEXES</code> will only return <code>ConsumedCapacity</code> information for table(s).</p></li>  <li>   <p><code>TOTAL</code> - The response includes only the aggregate <code>ConsumedCapacity</code> for the operation.</p></li>  <li>   <p><code>NONE</code> - No <code>ConsumedCapacity</code> details are included in the response.</p></li> </ul><br>
     ///   - [`return_item_collection_metrics(ReturnItemCollectionMetrics)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::return_item_collection_metrics) / [`set_return_item_collection_metrics(Option<ReturnItemCollectionMetrics>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_return_item_collection_metrics):<br>required: **false**<br><p>Determines whether item collection metrics are returned. If set to <code>SIZE</code>, the response includes statistics about item collections, if any, that were modified during the operation are returned in the response. If set to <code>NONE</code> (the default), no statistics are returned.</p><br>
     ///   - [`update_expression(impl Into<String>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::update_expression) / [`set_update_expression(Option<String>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_update_expression):<br>required: **false**<br><p>An expression that defines one or more attributes to be updated, the action to be performed on them, and new values for them.</p> <p>The following action values are available for <code>UpdateExpression</code>.</p> <ul>  <li>   <p><code>SET</code> - Adds one or more attributes and values to an item. If any of these attributes already exist, they are replaced by the new values. You can also use <code>SET</code> to add or subtract from an attribute that is of type Number. For example: <code>SET myNum = myNum + :val</code></p>   <p><code>SET</code> supports the following functions:</p>   <ul>    <li>     <p><code>if_not_exists (path, operand)</code> - if the item does not contain an attribute at the specified path, then <code>if_not_exists</code> evaluates to operand; otherwise, it evaluates to path. You can use this function to avoid overwriting an attribute that may already be present in the item.</p></li>    <li>     <p><code>list_append (operand, operand)</code> - evaluates to a list with a new element added to it. You can append the new element to the start or the end of the list by reversing the order of the operands.</p></li>   </ul>   <p>These function names are case-sensitive.</p></li>  <li>   <p><code>REMOVE</code> - Removes one or more attributes from an item.</p></li>  <li>   <p><code>ADD</code> - Adds the specified value to the item, if the attribute does not already exist. If the attribute does exist, then the behavior of <code>ADD</code> depends on the data type of the attribute:</p>   <ul>    <li>     <p>If the existing attribute is a number, and if <code>Value</code> is also a number, then <code>Value</code> is mathematically added to the existing attribute. If <code>Value</code> is a negative number, then it is subtracted from the existing attribute.</p><note>      <p>If you use <code>ADD</code> to increment or decrement a number value for an item that doesn't exist before the update, DynamoDB uses <code>0</code> as the initial value.</p>      <p>Similarly, if you use <code>ADD</code> for an existing item to increment or decrement an attribute value that doesn't exist before the update, DynamoDB uses <code>0</code> as the initial value. For example, suppose that the item you want to update doesn't have an attribute named <code>itemcount</code>, but you decide to <code>ADD</code> the number <code>3</code> to this attribute anyway. DynamoDB will create the <code>itemcount</code> attribute, set its initial value to <code>0</code>, and finally add <code>3</code> to it. The result will be a new <code>itemcount</code> attribute in the item, with a value of <code>3</code>.</p>     </note></li>    <li>     <p>If the existing data type is a set and if <code>Value</code> is also a set, then <code>Value</code> is added to the existing set. For example, if the attribute value is the set <code>\[1,2\]</code>, and the <code>ADD</code> action specified <code>\[3\]</code>, then the final attribute value is <code>\[1,2,3\]</code>. An error occurs if an <code>ADD</code> action is specified for a set attribute and the attribute type specified does not match the existing set type.</p>     <p>Both sets must have the same primitive data type. For example, if the existing data type is a set of strings, the <code>Value</code> must also be a set of strings.</p></li>   </ul><important>    <p>The <code>ADD</code> action only supports Number and set data types. In addition, <code>ADD</code> can only be used on top-level attributes, not nested attributes.</p>   </important></li>  <li>   <p><code>DELETE</code> - Deletes an element from a set.</p>   <p>If a set of values is specified, then those values are subtracted from the old set. For example, if the attribute value was the set <code>\[a,b,c\]</code> and the <code>DELETE</code> action specifies <code>\[a,c\]</code>, then the final attribute value is <code>\[b\]</code>. Specifying an empty set is an error.</p><important>    <p>The <code>DELETE</code> action only supports set data types. In addition, <code>DELETE</code> can only be used on top-level attributes, not nested attributes.</p>   </important></li> </ul> <p>You can have many actions in a single expression, such as the following: <code>SET a=:value1, b=:value2 DELETE :value3, :value4, :value5</code></p> <p>For more information on update expressions, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.Modifying.html">Modifying Items and Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`update_expression(impl Into<String>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::update_expression) / [`set_update_expression(Option<String>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_update_expression):<br>required: **false**<br><p>An expression that defines one or more attributes to be updated, the action to be performed on them, and new values for them.</p> <p>The following action values are available for <code>UpdateExpression</code>.</p> <ul>  <li>   <p><code>SET</code> - Adds one or more attributes and values to an item. If any of these attributes already exist, they are replaced by the new values. You can also use <code>SET</code> to add or subtract from an attribute that is of type Number. For example: <code>SET myNum = myNum + :val</code></p>   <p><code>SET</code> supports the following functions:</p>   <ul>    <li>     <p><code>if_not_exists (path, operand)</code> - if the item does not contain an attribute at the specified path, then <code>if_not_exists</code> evaluates to operand; otherwise, it evaluates to path. You can use this function to avoid overwriting an attribute that may already be present in the item.</p></li>    <li>     <p><code>list_append (operand, operand)</code> - evaluates to a list with a new element added to it. You can append the new element to the start or the end of the list by reversing the order of the operands.</p></li>   </ul>   <p>These function names are case-sensitive.</p></li>  <li>   <p><code>REMOVE</code> - Removes one or more attributes from an item.</p></li>  <li>   <p><code>ADD</code> - Adds the specified value to the item, if the attribute does not already exist. If the attribute does exist, then the behavior of <code>ADD</code> depends on the data type of the attribute:</p>   <ul>    <li>     <p>If the existing attribute is a number, and if <code>Value</code> is also a number, then <code>Value</code> is mathematically added to the existing attribute. If <code>Value</code> is a negative number, then it is subtracted from the existing attribute.</p><note>      <p>If you use <code>ADD</code> to increment or decrement a number value for an item that doesn't exist before the update, DynamoDB uses <code>0</code> as the initial value.</p>      <p>Similarly, if you use <code>ADD</code> for an existing item to increment or decrement an attribute value that doesn't exist before the update, DynamoDB uses <code>0</code> as the initial value. For example, suppose that the item you want to update doesn't have an attribute named <code>itemcount</code>, but you decide to <code>ADD</code> the number <code>3</code> to this attribute anyway. DynamoDB will create the <code>itemcount</code> attribute, set its initial value to <code>0</code>, and finally add <code>3</code> to it. The result will be a new <code>itemcount</code> attribute in the item, with a value of <code>3</code>.</p>     </note></li>    <li>     <p>If the existing data type is a set and if <code>Value</code> is also a set, then <code>Value</code> is added to the existing set. For example, if the attribute value is the set <code>\[1,2\]</code>, and the <code>ADD</code> action specified <code>\[3\]</code>, then the final attribute value is <code>\[1,2,3\]</code>. An error occurs if an <code>ADD</code> action is specified for a set attribute and the attribute type specified does not match the existing set type.</p>     <p>Both sets must have the same primitive data type. For example, if the existing data type is a set of strings, the <code>Value</code> must also be a set of strings.</p></li>   </ul><important>    <p>The <code>ADD</code> action only supports Number and set data types.</p>   </important></li>  <li>   <p><code>DELETE</code> - Deletes an element from a set.</p>   <p>If a set of values is specified, then those values are subtracted from the old set. For example, if the attribute value was the set <code>\[a,b,c\]</code> and the <code>DELETE</code> action specifies <code>\[a,c\]</code>, then the final attribute value is <code>\[b\]</code>. Specifying an empty set is an error.</p><important>    <p>The <code>DELETE</code> action only supports set data types.</p>   </important></li> </ul> <p>You can have many actions in a single expression, such as the following: <code>SET a=:value1, b=:value2 DELETE :value3, :value4, :value5</code></p> <p>For more information on update expressions, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.Modifying.html">Modifying Items and Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`condition_expression(impl Into<String>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::condition_expression) / [`set_condition_expression(Option<String>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_condition_expression):<br>required: **false**<br><p>A condition that must be satisfied in order for a conditional update to succeed.</p> <p>An expression can contain any of the following:</p> <ul>  <li>   <p>Functions: <code>attribute_exists | attribute_not_exists | attribute_type | contains | begins_with | size</code></p>   <p>These function names are case-sensitive.</p></li>  <li>   <p>Comparison operators: <code>= | &lt;&gt; | &lt; | &gt; | &lt;= | &gt;= | BETWEEN | IN </code></p></li>  <li>   <p>Logical operators: <code>AND | OR | NOT</code></p></li> </ul> <p>For more information about condition expressions, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html">Specifying Conditions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`expression_attribute_names(impl Into<String>, impl Into<String>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::expression_attribute_names) / [`set_expression_attribute_names(Option<HashMap::<String, String>>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_expression_attribute_names):<br>required: **false**<br><p>One or more substitution tokens for attribute names in an expression. The following are some use cases for using <code>ExpressionAttributeNames</code>:</p> <ul>  <li>   <p>To access an attribute whose name conflicts with a DynamoDB reserved word.</p></li>  <li>   <p>To create a placeholder for repeating occurrences of an attribute name in an expression.</p></li>  <li>   <p>To prevent special characters in an attribute name from being misinterpreted in an expression.</p></li> </ul> <p>Use the <b>#</b> character in an expression to dereference an attribute name. For example, consider the following attribute name:</p> <ul>  <li>   <p><code>Percentile</code></p></li> </ul> <p>The name of this attribute conflicts with a reserved word, so it cannot be used directly in an expression. (For the complete list of reserved words, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved Words</a> in the <i>Amazon DynamoDB Developer Guide</i>.) To work around this, you could specify the following for <code>ExpressionAttributeNames</code>:</p> <ul>  <li>   <p><code>{"#P":"Percentile"}</code></p></li> </ul> <p>You could then use this substitution in an expression, as in this example:</p> <ul>  <li>   <p><code>#P = :val</code></p></li> </ul><note>  <p>Tokens that begin with the <b>:</b> character are <i>expression attribute values</i>, which are placeholders for the actual value at runtime.</p> </note> <p>For more information about expression attribute names, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html">Specifying Item Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`expression_attribute_values(impl Into<String>, AttributeValue)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::expression_attribute_values) / [`set_expression_attribute_values(Option<HashMap::<String, AttributeValue>>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_expression_attribute_values):<br>required: **false**<br><p>One or more values that can be substituted in an expression.</p> <p>Use the <b>:</b> (colon) character in an expression to dereference an attribute value. For example, suppose that you wanted to check whether the value of the <code>ProductStatus</code> attribute was one of the following:</p> <p><code>Available | Backordered | Discontinued</code></p> <p>You would first need to specify <code>ExpressionAttributeValues</code> as follows:</p> <p><code>{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }</code></p> <p>You could then use these values in an expression, such as this:</p> <p><code>ProductStatus IN (:avail, :back, :disc)</code></p> <p>For more information on expression attribute values, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html">Condition Expressions</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`return_values_on_condition_check_failure(ReturnValuesOnConditionCheckFailure)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::return_values_on_condition_check_failure) / [`set_return_values_on_condition_check_failure(Option<ReturnValuesOnConditionCheckFailure>)`](crate::operation::update_item::builders::UpdateItemFluentBuilder::set_return_values_on_condition_check_failure):<br>required: **false**<br><p>An optional parameter that returns the item attributes for an <code>UpdateItem</code> operation that failed a condition check.</p> <p>There is no additional cost associated with requesting a return value aside from the small network and processing overhead of receiving a larger response. No read capacity units are consumed.</p><br>
     /// - On success, responds with [`UpdateItemOutput`](crate::operation::update_item::UpdateItemOutput) with field(s):
     ///   - [`attributes(Option<HashMap::<String, AttributeValue>>)`](crate::operation::update_item::UpdateItemOutput::attributes): <p>A map of attribute values as they appear before or after the <code>UpdateItem</code> operation, as determined by the <code>ReturnValues</code> parameter.</p> <p>The <code>Attributes</code> map is only present if the update was successful and <code>ReturnValues</code> was specified as something other than <code>NONE</code> in the request. Each element represents one attribute.</p>
     ///   - [`consumed_capacity(Option<ConsumedCapacity>)`](crate::operation::update_item::UpdateItemOutput::consumed_capacity): <p>The capacity units consumed by the <code>UpdateItem</code> operation. The data returned includes the total provisioned throughput consumed, along with statistics for the table and any indexes involved in the operation. <code>ConsumedCapacity</code> is only returned if the <code>ReturnConsumedCapacity</code> parameter was specified. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/read-write-operations.html#write-operation-consumption">Capacity unity consumption for write operations</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     ///   - [`item_collection_metrics(Option<ItemCollectionMetrics>)`](crate::operation::update_item::UpdateItemOutput::item_collection_metrics): <p>Information about item collections, if any, that were affected by the <code>UpdateItem</code> operation. <code>ItemCollectionMetrics</code> is only returned if the <code>ReturnItemCollectionMetrics</code> parameter was specified. If the table does not have any local secondary indexes, this information is not returned in the response.</p> <p>Each <code>ItemCollectionMetrics</code> element consists of:</p> <ul>  <li>   <p><code>ItemCollectionKey</code> - The partition key value of the item collection. This is the same as the partition key value of the item itself.</p></li>  <li>   <p><code>SizeEstimateRangeGB</code> - An estimate of item collection size, in gigabytes. This value is a two-element array containing a lower bound and an upper bound for the estimate. The estimate includes the size of all the items in the table, plus the size of all attributes projected into all of the local secondary indexes on that table. Use this estimate to measure whether a local secondary index is approaching its size limit.</p>   <p>The estimate is subject to change over time; therefore, do not rely on the precision or accuracy of the estimate.</p></li> </ul>
     /// - On failure, responds with [`SdkError<UpdateItemError>`](crate::operation::update_item::UpdateItemError)
     pub fn update_item(&self) -> crate::operation::update_item::builders::UpdateItemFluentBuilder {

25 25	`crate::operation::update_item::builders::UpdateItemFluentBuilder::new(self.handle.clone())`
26 26	`}`
27 27	`}`

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 impl super::Client {
     /// Constructs a fluent builder for the [`UpdateTable`](crate::operation::update_table::builders::UpdateTableFluentBuilder) operation.
     ///
     /// - The fluent builder is configurable:
     ///   - [`attribute_definitions(AttributeDefinition)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::attribute_definitions) / [`set_attribute_definitions(Option<Vec::<AttributeDefinition>>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_attribute_definitions):<br>required: **false**<br><p>An array of attributes that describe the key schema for the table and indexes. If you are adding a new global secondary index to the table, <code>AttributeDefinitions</code> must include the key element(s) of the new index.</p><br>
     ///   - [`table_name(impl Into<String>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::table_name) / [`set_table_name(Option<String>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_table_name):<br>required: **true**<br><p>The name of the table to be updated. You can also provide the Amazon Resource Name (ARN) of the table in this parameter.</p><br>
     ///   - [`billing_mode(BillingMode)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::billing_mode) / [`set_billing_mode(Option<BillingMode>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_billing_mode):<br>required: **false**<br><p>Controls how you are charged for read and write throughput and how you manage capacity. When switching from pay-per-request to provisioned capacity, initial provisioned capacity values must be set. The initial provisioned capacity values are estimated based on the consumed read and write capacity of your table and global secondary indexes over the past 30 minutes.</p> <ul>  <li>   <p><code>PAY_PER_REQUEST</code> - We recommend using <code>PAY_PER_REQUEST</code> for most DynamoDB workloads. <code>PAY_PER_REQUEST</code> sets the billing mode to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/on-demand-capacity-mode.html">On-demand capacity mode</a>.</p></li>  <li>   <p><code>PROVISIONED</code> - We recommend using <code>PROVISIONED</code> for steady workloads with predictable growth where capacity requirements can be reliably forecasted. <code>PROVISIONED</code> sets the billing mode to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/provisioned-capacity-mode.html">Provisioned capacity mode</a>.</p></li> </ul><br>
     ///   - [`provisioned_throughput(ProvisionedThroughput)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::provisioned_throughput) / [`set_provisioned_throughput(Option<ProvisionedThroughput>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_provisioned_throughput):<br>required: **false**<br><p>The new provisioned throughput settings for the specified table or index.</p><br>

     ///   - [`global_secondary_index_updates(GlobalSecondaryIndexUpdate)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::global_secondary_index_updates) / [`set_global_secondary_index_updates(Option<Vec::<GlobalSecondaryIndexUpdate>>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_global_secondary_index_updates):<br>required: **false**<br><p>An array of one or more global secondary indexes for the table. For each index in the array, you can request one action:</p> <ul>  <li>   <p><code>Create</code> - add a new global secondary index to the table.</p></li>  <li>   <p><code>Update</code> - modify the provisioned throughput settings of an existing global secondary index.</p></li>  <li>   <p><code>Delete</code> - remove a global secondary index from the table.</p></li> </ul> <p>You can create or delete only one global secondary index per <code>UpdateTable</code> operation.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.OnlineOps.html">Managing Global Secondary Indexes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><br>
     ///   - [`stream_specification(StreamSpecification)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::stream_specification) / [`set_stream_specification(Option<StreamSpecification>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_stream_specification):<br>required: **false**<br><p>Represents the DynamoDB Streams configuration for the table.</p><note>  <p>You receive a <code>ValidationException</code> if you try to enable a stream on a table that already has a stream, or if you try to disable a stream on a table that doesn't have a stream.</p> </note><br>
     ///   - [`sse_specification(SseSpecification)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::sse_specification) / [`set_sse_specification(Option<SseSpecification>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_sse_specification):<br>required: **false**<br><p>The new server-side encryption settings for the specified table.</p><br>
     ///   - [`replica_updates(ReplicationGroupUpdate)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::replica_updates) / [`set_replica_updates(Option<Vec::<ReplicationGroupUpdate>>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_replica_updates):<br>required: **false**<br><p>A list of replica update actions (create, delete, or update) for the table.</p><br>
     ///   - [`table_class(TableClass)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::table_class) / [`set_table_class(Option<TableClass>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_table_class):<br>required: **false**<br><p>The table class of the table to be updated. Valid values are <code>STANDARD</code> and <code>STANDARD_INFREQUENT_ACCESS</code>.</p><br>
     ///   - [`deletion_protection_enabled(bool)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::deletion_protection_enabled) / [`set_deletion_protection_enabled(Option<bool>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_deletion_protection_enabled):<br>required: **false**<br><p>Indicates whether deletion protection is to be enabled (true) or disabled (false) on the table.</p><br>
     ///   - [`multi_region_consistency(MultiRegionConsistency)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::multi_region_consistency) / [`set_multi_region_consistency(Option<MultiRegionConsistency>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_multi_region_consistency):<br>required: **false**<br><p>Specifies the consistency mode for a new global table. This parameter is only valid when you create a global table by specifying one or more <a href="https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ReplicationGroupUpdate.html#DDB-Type-ReplicationGroupUpdate-Create">Create</a> actions in the <a href="https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html#DDB-UpdateTable-request-ReplicaUpdates">ReplicaUpdates</a> action list.</p> <p>You can specify one of the following consistency modes:</p> <ul>  <li>   <p><code>EVENTUAL</code>: Configures a new global table for multi-Region eventual consistency (MREC). This is the default consistency mode for global tables.</p></li>  <li>   <p><code>STRONG</code>: Configures a new global table for multi-Region strong consistency (MRSC).</p></li> </ul> <p>If you don't specify this field, the global table consistency mode defaults to <code>EVENTUAL</code>. For more information about global tables consistency modes, see <a href="https://docs.aws.amazon.com/V2globaltables_HowItWorks.html#V2globaltables_HowItWorks.consistency-modes"> Consistency modes</a> in DynamoDB developer guide.</p><br>
     ///   - [`global_table_witness_updates(GlobalTableWitnessGroupUpdate)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::global_table_witness_updates) / [`set_global_table_witness_updates(Option<Vec::<GlobalTableWitnessGroupUpdate>>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_global_table_witness_updates):<br>required: **false**<br><p>A list of witness updates for a MRSC global table. A witness provides a cost-effective alternative to a full replica in a MRSC global table by maintaining replicated change data written to global table replicas. You cannot perform read or write operations on a witness. For each witness, you can request one action:</p> <ul>  <li>   <p><code>Create</code> - add a new witness to the global table.</p></li>  <li>   <p><code>Delete</code> - remove a witness from the global table.</p></li> </ul> <p>You can create or delete only one witness per <code>UpdateTable</code> operation.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_HowItWorks.html#V2globaltables_HowItWorks.consistency-modes">Multi-Region strong consistency (MRSC)</a> in the Amazon DynamoDB Developer Guide</p><br>
     ///   - [`on_demand_throughput(OnDemandThroughput)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::on_demand_throughput) / [`set_on_demand_throughput(Option<OnDemandThroughput>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_on_demand_throughput):<br>required: **false**<br><p>Updates the maximum number of read and write units for the specified table in on-demand capacity mode. If you use this parameter, you must specify <code>MaxReadRequestUnits</code>, <code>MaxWriteRequestUnits</code>, or both.</p><br>
     ///   - [`warm_throughput(WarmThroughput)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::warm_throughput) / [`set_warm_throughput(Option<WarmThroughput>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_warm_throughput):<br>required: **false**<br><p>Represents the warm throughput (in read units per second and write units per second) for updating a table.</p><br>
     ///   - [`global_table_settings_replication_mode(GlobalTableSettingsReplicationMode)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::global_table_settings_replication_mode) / [`set_global_table_settings_replication_mode(Option<GlobalTableSettingsReplicationMode>)`](crate::operation::update_table::builders::UpdateTableFluentBuilder::set_global_table_settings_replication_mode):<br>required: **false**<br><p>Controls the settings replication mode for a global table replica. This attribute can be defined using UpdateTable operation only on a regional table with values:</p> <ul>  <li>   <p><code>ENABLED</code>: Defines settings replication on a regional table to be used as a source table for creating Multi-Account Global Table.</p></li>  <li>   <p><code>DISABLED</code>: Remove settings replication on a regional table. Settings replication needs to be defined to ENABLED again in order to create a Multi-Account Global Table using this table.</p></li> </ul><br>
     /// - On success, responds with [`UpdateTableOutput`](crate::operation::update_table::UpdateTableOutput) with field(s):
     ///   - [`table_description(Option<TableDescription>)`](crate::operation::update_table::UpdateTableOutput::table_description): <p>Represents the properties of the table.</p>
     /// - On failure, responds with [`SdkError<UpdateTableError>`](crate::operation::update_table::UpdateTableError)
     pub fn update_table(&self) -> crate::operation::update_table::builders::UpdateTableFluentBuilder {
         crate::operation::update_table::builders::UpdateTableFluentBuilder::new(self.handle.clone())
-26
+    }
-27
+}