aws-sdk-s3 1.135.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub use ::aws_smithy_runtime_api::client::endpoint::EndpointFuture;
pub use ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver;
pub use ::aws_smithy_types::endpoint::Endpoint;

/// Interceptor that tracks endpoint override business metric.
#[derive(Debug, Default)]
pub(crate) struct EndpointOverrideFeatureTrackerInterceptor;

#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EndpointOverrideFeatureTrackerInterceptor {
    fn name(&self) -> &'static str {
        "EndpointOverrideFeatureTrackerInterceptor"
    }

    fn read_before_execution(
        &self,
        _context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<'_>,
        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
        if cfg.load::<::aws_types::endpoint_config::EndpointUrl>().is_some() {
            cfg.interceptor_state()
                .store_append(::aws_runtime::sdk_feature::AwsSdkFeature::EndpointOverride);
        }
        ::std::result::Result::Ok(())
    }
}

#[cfg(test)]
mod test {

    /// region is not a valid DNS-suffix
    #[test]
    fn test_1() {
        let params = crate::config::endpoint::Params::builder()
            .region("a b".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [region is not a valid DNS-suffix]");
        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
    }

    /// Invalid access point ARN: Not S3
    #[test]
    fn test_2() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:not-s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Invalid ARN: The ARN was not for the S3 service, found: not-s3 [Invalid access point ARN: Not S3]");
        assert_eq!(format!("{}", error), "Invalid ARN: The ARN was not for the S3 service, found: not-s3")
    }

    /// Invalid access point ARN: invalid resource
    #[test]
    fn test_3() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint:more-data".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: The ARN may only contain a single resource component after `accesspoint`. [Invalid access point ARN: invalid resource]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
        )
    }

    /// Invalid access point ARN: invalid no ap name
    #[test]
    fn test_4() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided [Invalid access point ARN: invalid no ap name]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
        )
    }

    /// Invalid access point ARN: AccountId is invalid
    #[test]
    fn test_5() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456_789012:accesspoint:apname".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123456_789012` [Invalid access point ARN: AccountId is invalid]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123456_789012`"
        )
    }

    /// Invalid access point ARN: access point name is invalid
    #[test]
    fn test_6() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:ap_name".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name` [Invalid access point ARN: access point name is invalid]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name`"
        )
    }

    /// Access points (disable access points explicitly false)
    #[test]
    fn test_7() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_access_points(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

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

    /// Bucket region is invalid
    #[test]
    fn test_9() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_access_points(false)
            .bucket("arn:aws:s3:us-west -2:123456789012:accesspoint:myendpoint".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-west -2` (invalid DNS name) [Bucket region is invalid]");
        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-west -2` (invalid DNS name)")
    }

    /// Access points when Access points explicitly disabled (used for CreateBucket)
    #[test]
    fn test_10() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_access_points(true)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Access points are not supported for this operation [Access points when Access points explicitly disabled (used for CreateBucket)]");
        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
    }

    /// missing arn type
    #[test]
    fn test_11() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_access_points(true)
            .bucket("arn:aws:s3:us-west-2:123456789012:".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN [missing arn type]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN"
        )
    }

    /// SDK::Host + access point + Dualstack is an error
    #[test]
    fn test_12() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .endpoint("https://beta.example.com".to_string())
            .region("cn-north-1".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + access point + Dualstack is an error]",
        );
        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
    }

    /// Access point ARN with FIPS & Dualstack
    #[test]
    fn test_13() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_access_points(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// Access point ARN with Dualstack
    #[test]
    fn test_14() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_access_points(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// vanilla MRAP
    #[test]
    fn test_15() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
            .region("us-east-1".to_string())
            .disable_multi_region_access_points(false)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .build()
        );
    }

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

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

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

    /// MRAP explicitly disabled
    #[test]
    fn test_19() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
            .region("us-east-1".to_string())
            .disable_multi_region_access_points(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Invalid configuration: Multi-Region Access Point ARNs are disabled. [MRAP explicitly disabled]");
        assert_eq!(
            format!("{}", error),
            "Invalid configuration: Multi-Region Access Point ARNs are disabled."
        )
    }

    /// Dual-stack endpoint with path-style forced
    #[test]
    fn test_20() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("bucketname".to_string())
            .region("us-west-2".to_string())
            .force_path_style(true)
            .use_fips(false)
            .accelerate(false)
            .use_dual_stack(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucketname");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucketname")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

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

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

    /// implicit path style bucket + dualstack
    #[test]
    fn test_23() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99_ab".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/99_ab");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-west-2.amazonaws.com/99_ab")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// implicit path style bucket + dualstack
    #[test]
    fn test_24() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99_ab".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .endpoint("http://abc.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint
            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [implicit path style bucket + dualstack]");
        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
    }

    /// don't allow URL injections in the bucket
    #[test]
    fn test_25() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("example.com#".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/example.com%23");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-west-2.amazonaws.com/example.com%23")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// URI encode bucket names in the path
    #[test]
    fn test_26() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("bucket name".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket%20name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-west-2.amazonaws.com/bucket%20name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// scheme is respected
    #[test]
    fn test_27() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99_ab".to_string())
            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// scheme is respected (virtual addressing)
    #[test]
    fn test_28() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucketname".to_string())
            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo".to_string())
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// path style + implicit private link
    #[test]
    fn test_29() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99_ab".to_string())
            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// invalid Endpoint override
    #[test]
    fn test_30() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucketname".to_string())
            .endpoint("abcde://nota#url".to_string())
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Custom endpoint `abcde://nota#url` was not a valid URI [invalid Endpoint override]");
        assert_eq!(format!("{}", error), "Custom endpoint `abcde://nota#url` was not a valid URI")
    }

    /// using an IPv4 address forces path style
    #[test]
    fn test_31() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucketname".to_string())
            .endpoint("https://123.123.0.1".to_string())
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123.123.0.1/bucketname");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123.123.0.1/bucketname")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// vanilla access point arn with region mismatch and UseArnRegion=false
    #[test]
    fn test_32() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:us-east-1:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .use_arn_region(false)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [vanilla access point arn with region mismatch and UseArnRegion=false]");
        assert_eq!(
            format!("{}", error),
            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
        )
    }

    /// vanilla access point arn with region mismatch and UseArnRegion unset
    #[test]
    fn test_33() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("us-east-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// vanilla access point arn with region mismatch and UseArnRegion=true
    #[test]
    fn test_34() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .use_arn_region(true)
            .region("us-east-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// subdomains are not allowed in virtual buckets
    #[test]
    fn test_35() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("bucket.name".to_string())
            .region("us-east-1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/bucket.name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-east-1.amazonaws.com/bucket.name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// bucket names with 3 characters are allowed in virtual buckets
    #[test]
    fn test_36() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("aaa".to_string())
            .region("us-east-1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://aaa.s3.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://aaa.s3.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// bucket names with fewer than 3 characters are not allowed in virtual host
    #[test]
    fn test_37() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("aa".to_string())
            .region("us-east-1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/aa");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-east-1.amazonaws.com/aa")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// bucket names with uppercase characters are not allowed in virtual host
    #[test]
    fn test_38() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("BucketName".to_string())
            .region("us-east-1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/BucketName");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-east-1.amazonaws.com/BucketName")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// subdomains are allowed in virtual buckets on http endpoints
    #[test]
    fn test_39() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("bucket.name".to_string())
            .region("us-east-1".to_string())
            .endpoint("http://example.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.name.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://bucket.name.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// no region set
    #[test]
    fn test_40() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("bucket-name".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: A region must be set when sending requests to S3. [no region set]");
        assert_eq!(format!("{}", error), "A region must be set when sending requests to S3.")
    }

    /// UseGlobalEndpoints=true, region=us-east-1 uses the global endpoint
    #[test]
    fn test_41() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// UseGlobalEndpoints=true, region=us-west-2 uses the regional endpoint
    #[test]
    fn test_42() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_global_endpoint(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// UseGlobalEndpoints=true, region=cn-north-1 uses the regional endpoint
    #[test]
    fn test_43() {
        let params = crate::config::endpoint::Params::builder()
            .region("cn-north-1".to_string())
            .use_global_endpoint(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.cn-north-1.amazonaws.com.cn")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// UseGlobalEndpoints=true, region=us-east-1, fips=true uses the regional endpoint with fips
    #[test]
    fn test_44() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// UseGlobalEndpoints=true, region=us-east-1, dualstack=true uses the regional endpoint with dualstack
    #[test]
    fn test_45() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// UseGlobalEndpoints=true, region=us-east-1, dualstack and fips uses the regional endpoint with fips/dualstack
    #[test]
    fn test_46() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// UseGlobalEndpoints=true, region=us-east-1 with custom endpoint, uses custom
    #[test]
    fn test_47() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .endpoint("https://example.com".to_string())
            .use_global_endpoint(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// UseGlobalEndpoints=true, region=us-west-2 with custom endpoint, uses custom
    #[test]
    fn test_48() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .endpoint("https://example.com".to_string())
            .use_global_endpoint(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// UseGlobalEndpoints=true, region=us-east-1 with accelerate on non bucket case uses the global endpoint and ignores accelerate
    #[test]
    fn test_49() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global region uses the global endpoint
    #[test]
    fn test_50() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global region with fips uses the regional endpoint
    #[test]
    fn test_51() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global region with dualstack uses the regional endpoint
    #[test]
    fn test_52() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global region with fips and dualstack uses the regional endpoint
    #[test]
    fn test_53() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global region with accelerate on non-bucket case, uses global endpoint and ignores accelerate
    #[test]
    fn test_54() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global region with custom endpoint, uses custom
    #[test]
    fn test_55() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .endpoint("https://example.com".to_string())
            .use_global_endpoint(false)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, aws-global region uses the global endpoint
    #[test]
    fn test_56() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, aws-global region with Prefix, and Key uses the global endpoint. Prefix and Key parameters should not be used in endpoint evaluation.
    #[test]
    fn test_57() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .prefix("prefix".to_string())
            .key("key".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, aws-global region with Copy Source, and Key uses the global endpoint. Copy Source and Key parameters should not be used in endpoint evaluation.
    #[test]
    fn test_58() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .copy_source("/copy/source".to_string())
            .key("key".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, aws-global region with fips uses the regional fips endpoint
    #[test]
    fn test_59() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, aws-global region with dualstack uses the regional dualstack endpoint
    #[test]
    fn test_60() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, aws-global region with fips/dualstack uses the regional fips/dualstack endpoint
    #[test]
    fn test_61() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, aws-global region with accelerate uses the global accelerate endpoint
    #[test]
    fn test_62() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-accelerate.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, aws-global region with custom endpoint
    #[test]
    fn test_63() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .endpoint("https://example.com".to_string())
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, UseGlobalEndpoint and us-east-1 region uses the global endpoint
    #[test]
    fn test_64() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, UseGlobalEndpoint and us-west-2 region uses the regional endpoint
    #[test]
    fn test_65() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_global_endpoint(true)
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and fips uses the regional fips endpoint
    #[test]
    fn test_66() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .bucket("bucket-name".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and dualstack uses the regional dualstack endpoint
    #[test]
    fn test_67() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and accelerate uses the global accelerate endpoint
    #[test]
    fn test_68() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-accelerate.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing, UseGlobalEndpoint and us-east-1 region with custom endpoint
    #[test]
    fn test_69() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .endpoint("https://example.com".to_string())
            .use_global_endpoint(true)
            .bucket("bucket-name".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// ForcePathStyle, aws-global region uses the global endpoint
    #[test]
    fn test_70() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// ForcePathStyle, aws-global region with fips is invalid
    #[test]
    fn test_71() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.us-east-1.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// ForcePathStyle, aws-global region with dualstack uses regional dualstack endpoint
    #[test]
    fn test_72() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// ForcePathStyle, aws-global region custom endpoint uses the custom endpoint
    #[test]
    fn test_73() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .endpoint("https://example.com".to_string())
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://example.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region uses the global endpoint
    #[test]
    fn test_74() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket-name".to_string())
            .use_global_endpoint(true)
            .force_path_style(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// ForcePathStyle, UseGlobalEndpoint us-west-2 region uses the regional endpoint
    #[test]
    fn test_75() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("bucket-name".to_string())
            .use_global_endpoint(true)
            .force_path_style(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region, dualstack uses the regional dualstack endpoint
    #[test]
    fn test_76() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket-name".to_string())
            .use_global_endpoint(true)
            .force_path_style(true)
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region custom endpoint uses the custom endpoint
    #[test]
    fn test_77() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket-name".to_string())
            .endpoint("https://example.com".to_string())
            .use_global_endpoint(true)
            .force_path_style(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://example.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// ARN with aws-global region and  UseArnRegion uses the regional endpoint
    #[test]
    fn test_78() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_arn_region(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// cross partition MRAP ARN is an error
    #[test]
    fn test_79() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws-cn:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
            .region("us-west-1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but bucket referred to partition `aws-cn` [cross partition MRAP ARN is an error]");
        assert_eq!(
            format!("{}", error),
            "Client was configured for partition `aws` but bucket referred to partition `aws-cn`"
        )
    }

    /// Endpoint override, accesspoint with HTTP, port
    #[test]
    fn test_80() {
        let params = crate::config::endpoint::Params::builder()
            .endpoint("http://beta.example.com:1234".to_string())
            .region("us-west-2".to_string())
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://myendpoint-123456789012.beta.example.com:1234")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// Endpoint override, accesspoint with http, path, query, and port
    #[test]
    fn test_81() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .endpoint("http://beta.example.com:1234/path".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234/path");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://myendpoint-123456789012.beta.example.com:1234/path")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

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

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

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

    /// custom endpoint without FIPS/dualstack
    #[test]
    fn test_85() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .endpoint("http://beta.example.com:1234/path".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://beta.example.com:1234/path");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://beta.example.com:1234/path")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// s3 object lambda with access points disabled
    #[test]
    fn test_86() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .disable_access_points(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Access points are not supported for this operation [s3 object lambda with access points disabled]");
        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
    }

    /// non bucket + FIPS
    #[test]
    fn test_87() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// standard non bucket endpoint
    #[test]
    fn test_88() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// non bucket endpoint with FIPS + Dualstack
    #[test]
    fn test_89() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// non bucket endpoint with dualstack
    #[test]
    fn test_90() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// use global endpoint + IP address endpoint override
    #[test]
    fn test_91() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .endpoint("http://127.0.0.1".to_string())
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://127.0.0.1/bucket");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://127.0.0.1/bucket")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// non-dns endpoint + global endpoint
    #[test]
    fn test_92() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// endpoint override + use global endpoint
    #[test]
    fn test_93() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .use_global_endpoint(true)
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://foo.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// FIPS + dualstack + non-bucket endpoint
    #[test]
    fn test_94() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// FIPS + dualstack + non-DNS endpoint
    #[test]
    fn test_95() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .force_path_style(true)
            .use_fips(true)
            .use_dual_stack(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

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

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

    /// FIPS + bucket endpoint + force path style
    #[test]
    fn test_98() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .force_path_style(true)
            .use_fips(true)
            .use_dual_stack(false)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// bucket + FIPS + force path style
    #[test]
    fn test_99() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket".to_string())
            .force_path_style(true)
            .use_fips(true)
            .use_dual_stack(true)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// FIPS + dualstack + use global endpoint
    #[test]
    fn test_100() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// URI encoded bucket + use global endpoint
    #[test]
    fn test_101() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .use_global_endpoint(true)
            .endpoint("https://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [URI encoded bucket + use global endpoint]");
        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
    }

    /// FIPS + path based endpoint
    #[test]
    fn test_102() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// accelerate + dualstack + global endpoint
    #[test]
    fn test_103() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(true)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket.s3-accelerate.dualstack.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// dualstack + global endpoint + non URI safe bucket
    #[test]
    fn test_104() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .accelerate(false)
            .use_dual_stack(true)
            .use_fips(false)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// FIPS + uri encoded bucket
    #[test]
    fn test_105() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .force_path_style(true)
            .accelerate(false)
            .use_dual_stack(false)
            .use_fips(true)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

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

    /// FIPS + Dualstack + global endpoint + non-dns bucket
    #[test]
    fn test_107() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("bucket!".to_string())
            .accelerate(false)
            .use_dual_stack(true)
            .use_fips(true)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

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

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

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

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

    /// aws-global signs as us-east-1
    #[test]
    fn test_112() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket!".to_string())
            .use_fips(true)
            .accelerate(false)
            .use_dual_stack(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global signs as us-east-1
    #[test]
    fn test_113() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .accelerate(false)
            .endpoint("https://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.foo.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket.foo.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global + dualstack + path-only bucket
    #[test]
    fn test_114() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket!".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global + path-only bucket
    #[test]
    fn test_115() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket!".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global + fips + custom endpoint
    #[test]
    fn test_116() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket!".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .accelerate(false)
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + fips + custom endpoint]");
        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
    }

    /// aws-global, endpoint override & path only-bucket
    #[test]
    fn test_117() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket!".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .accelerate(false)
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://foo.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

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

    /// accelerate, dualstack + aws-global
    #[test]
    fn test_119() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .accelerate(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// FIPS + aws-global + path only bucket. This is not supported by S3 but we allow garbage in garbage out
    #[test]
    fn test_120() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket!".to_string())
            .force_path_style(true)
            .use_dual_stack(true)
            .use_fips(true)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// aws-global + FIPS + endpoint override.
    #[test]
    fn test_121() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_fips(true)
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + FIPS + endpoint override.]");
        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
    }

    /// force path style, FIPS, aws-global & endpoint override
    #[test]
    fn test_122() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket!".to_string())
            .force_path_style(true)
            .use_fips(true)
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint
            .expect_err("expected error: A custom endpoint cannot be combined with FIPS [force path style, FIPS, aws-global & endpoint override]");
        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
    }

    /// ip address causes path style to be forced
    #[test]
    fn test_123() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket".to_string())
            .endpoint("http://192.168.1.1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.1.1/bucket");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://192.168.1.1/bucket")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// endpoint override with aws-global region
    #[test]
    fn test_124() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint
            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override with aws-global region]");
        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
    }

    /// FIPS + path-only (TODO: consider making this an error)
    #[test]
    fn test_125() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .bucket("bucket!".to_string())
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// empty arn type
    #[test]
    fn test_126() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:not-s3:us-west-2:123456789012::myendpoint".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: No ARN type specified [empty arn type]");
        assert_eq!(format!("{}", error), "Invalid ARN: No ARN type specified")
    }

    /// path style can't be used with accelerate
    #[test]
    fn test_127() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("bucket!".to_string())
            .accelerate(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style can't be used with accelerate]");
        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
    }

    /// invalid region
    #[test]
    fn test_128() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2!".to_string())
            .bucket("bucket.subdomain".to_string())
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
    }

    /// invalid region
    #[test]
    fn test_129() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2!".to_string())
            .bucket("bucket".to_string())
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
    }

    /// empty arn type
    #[test]
    fn test_130() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:s3::123456789012:accesspoint:my_endpoint".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 Access Point Name [empty arn type]");
        assert_eq!(format!("{}", error), "Invalid Access Point Name")
    }

    /// empty arn type
    #[test]
    fn test_131() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint".to_string())
            .use_arn_region(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but ARN (`arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint`) has `aws-cn` [empty arn type]");
        assert_eq!(
            format!("{}", error),
            "Client was configured for partition `aws` but ARN (`arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint`) has `aws-cn`"
        )
    }

    /// invalid arn region
    #[test]
    fn test_132() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:s3-object-lambda:us-east_2:123456789012:accesspoint:my-endpoint".to_string())
            .use_arn_region(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_2` (invalid DNS name) [invalid arn region]");
        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_2` (invalid DNS name)")
    }

    /// invalid ARN outpost
    #[test]
    fn test_133() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op_01234567890123456/accesspoint/reports".to_string())
            .use_arn_region(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456` [invalid ARN outpost]",
        );
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456`"
        )
    }

    /// invalid ARN
    #[test]
    fn test_134() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/reports".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: expected an access point name [invalid ARN]");
        assert_eq!(format!("{}", error), "Invalid ARN: expected an access point name")
    }

    /// invalid ARN
    #[test]
    fn test_135() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a 4-component resource [invalid ARN]");
        assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
    }

    /// invalid outpost type
    #[test]
    fn test_136() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Expected an outpost type `accesspoint`, found not-accesspoint [invalid outpost type]");
        assert_eq!(format!("{}", error), "Expected an outpost type `accesspoint`, found not-accesspoint")
    }

    /// invalid outpost type
    #[test]
    fn test_137() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:s3-outposts:us-east_1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_1` (invalid DNS name) [invalid outpost type]");
        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_1` (invalid DNS name)")
    }

    /// invalid outpost type
    #[test]
    fn test_138() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("arn:aws:s3-outposts:us-east-1:12345_789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012` [invalid outpost type]",
        );
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012`"
        )
    }

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

    /// use global endpoint virtual addressing
    #[test]
    fn test_140() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("bucket".to_string())
            .endpoint("http://example.com".to_string())
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://bucket.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// global endpoint + ip address
    #[test]
    fn test_141() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("bucket".to_string())
            .endpoint("http://192.168.0.1".to_string())
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.0.1/bucket");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://192.168.0.1/bucket")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// invalid outpost type
    #[test]
    fn test_142() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("bucket!".to_string())
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-2.amazonaws.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-east-2.amazonaws.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// invalid outpost type
    #[test]
    fn test_143() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("bucket".to_string())
            .accelerate(true)
            .use_global_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket.s3-accelerate.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// use global endpoint + custom endpoint
    #[test]
    fn test_144() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("bucket!".to_string())
            .use_global_endpoint(true)
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://foo.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// use global endpoint, not us-east-1, force path style
    #[test]
    fn test_145() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-2".to_string())
            .bucket("bucket!".to_string())
            .use_global_endpoint(true)
            .force_path_style(true)
            .endpoint("http://foo.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://foo.com/bucket%21")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// vanilla virtual addressing@us-west-2
    #[test]
    fn test_146() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + dualstack@us-west-2
    #[test]
    fn test_147() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// accelerate + dualstack@us-west-2
    #[test]
    fn test_148() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(true)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// accelerate (dualstack=false)@us-west-2
    #[test]
    fn test_149() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(true)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-accelerate.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + fips@us-west-2
    #[test]
    fn test_150() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-fips.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + dualstack + fips@us-west-2
    #[test]
    fn test_151() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// accelerate + fips = error@us-west-2
    #[test]
    fn test_152() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(true)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@us-west-2]");
        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
    }

    /// vanilla virtual addressing@cn-north-1
    #[test]
    fn test_153() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("cn-north-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.cn-north-1.amazonaws.com.cn")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + dualstack@cn-north-1
    #[test]
    fn test_154() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("cn-north-1".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

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

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

    /// vanilla virtual addressing@af-south-1
    #[test]
    fn test_157() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.af-south-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + dualstack@af-south-1
    #[test]
    fn test_158() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3.dualstack.af-south-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// accelerate + dualstack@af-south-1
    #[test]
    fn test_159() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(true)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// accelerate (dualstack=false)@af-south-1
    #[test]
    fn test_160() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(true)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-accelerate.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + fips@af-south-1
    #[test]
    fn test_161() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-fips.af-south-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + dualstack + fips@af-south-1
    #[test]
    fn test_162() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// accelerate + fips = error@af-south-1
    #[test]
    fn test_163() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(true)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@af-south-1]");
        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
    }

    /// vanilla path style@us-west-2
    #[test]
    fn test_164() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// fips@us-gov-west-2, bucket is not S3-dns-compatible (subdomains)
    #[test]
    fn test_165() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket.with.dots".to_string())
            .region("us-gov-west-1".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-gov-west-1".to_string())
                )
                .build()
        );
    }

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

    /// path style + dualstack@us-west-2
    #[test]
    fn test_167() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .region("us-west-2".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// path style + arn is error@us-west-2
    #[test]
    fn test_168() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .force_path_style(true)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@us-west-2]");
        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
    }

    /// path style + invalid DNS name@us-west-2
    #[test]
    fn test_169() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99a_b".to_string())
            .force_path_style(true)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-west-2.amazonaws.com/99a_b")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// no path style + invalid DNS name@us-west-2
    #[test]
    fn test_170() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99a_b".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.us-west-2.amazonaws.com/99a_b")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// vanilla path style@cn-north-1
    #[test]
    fn test_171() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .region("cn-north-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.cn-north-1.amazonaws.com.cn/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

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

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

    /// path style + dualstack@cn-north-1
    #[test]
    fn test_174() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .region("cn-north-1".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// path style + arn is error@cn-north-1
    #[test]
    fn test_175() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .force_path_style(true)
            .region("cn-north-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@cn-north-1]");
        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
    }

    /// path style + invalid DNS name@cn-north-1
    #[test]
    fn test_176() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99a_b".to_string())
            .force_path_style(true)
            .region("cn-north-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// no path style + invalid DNS name@cn-north-1
    #[test]
    fn test_177() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99a_b".to_string())
            .region("cn-north-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// vanilla path style@af-south-1
    #[test]
    fn test_178() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.af-south-1.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// path style + fips@af-south-1
    #[test]
    fn test_179() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.af-south-1.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-fips.af-south-1.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

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

    /// path style + dualstack@af-south-1
    #[test]
    fn test_181() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .region("af-south-1".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.af-south-1.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.dualstack.af-south-1.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// path style + arn is error@af-south-1
    #[test]
    fn test_182() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .force_path_style(true)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@af-south-1]");
        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
    }

    /// path style + invalid DNS name@af-south-1
    #[test]
    fn test_183() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99a_b".to_string())
            .force_path_style(true)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.af-south-1.amazonaws.com/99a_b")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// no path style + invalid DNS name@af-south-1
    #[test]
    fn test_184() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("99a_b".to_string())
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3.af-south-1.amazonaws.com/99a_b")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + private link@us-west-2
    #[test]
    fn test_185() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// path style + private link@us-west-2
    #[test]
    fn test_186() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

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

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

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

    /// SDK::Host + access point ARN@us-west-2
    #[test]
    fn test_190() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .endpoint("https://beta.example.com".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.beta.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + private link@cn-north-1
    #[test]
    fn test_191() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("cn-north-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// path style + private link@cn-north-1
    #[test]
    fn test_192() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("cn-north-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

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

    /// SDK::Host + DualStack@cn-north-1
    #[test]
    fn test_194() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("cn-north-1".to_string())
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@cn-north-1]");
        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
    }

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

    /// SDK::Host + access point ARN@cn-north-1
    #[test]
    fn test_196() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .endpoint("https://beta.example.com".to_string())
            .region("cn-north-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.beta.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// virtual addressing + private link@af-south-1
    #[test]
    fn test_197() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(false)
            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// path style + private link@af-south-1
    #[test]
    fn test_198() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("bucket-name".to_string())
            .force_path_style(true)
            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

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

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

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

    /// SDK::Host + access point ARN@af-south-1
    #[test]
    fn test_202() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .endpoint("https://beta.example.com".to_string())
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.beta.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// vanilla access point arn@us-west-2
    #[test]
    fn test_203() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// access point arn + FIPS@us-west-2
    #[test]
    fn test_204() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// access point arn + accelerate = error@us-west-2
    #[test]
    fn test_205() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(true)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@us-west-2]");
        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
    }

    /// access point arn + FIPS + DualStack@us-west-2
    #[test]
    fn test_206() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// vanilla access point arn@cn-north-1
    #[test]
    fn test_207() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("cn-north-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

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

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

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

    /// vanilla access point arn@af-south-1
    #[test]
    fn test_211() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// access point arn + FIPS@af-south-1
    #[test]
    fn test_212() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// access point arn + accelerate = error@af-south-1
    #[test]
    fn test_213() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(true)
            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@af-south-1]");
        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
    }

    /// access point arn + FIPS + DualStack@af-south-1
    #[test]
    fn test_214() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
            .force_path_style(false)
            .region("af-south-1".to_string())
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// S3 outposts vanilla test
    #[test]
    fn test_215() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// S3 outposts custom endpoint
    #[test]
    fn test_216() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
            .endpoint("https://example.amazonaws.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.example.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://reports-123456789012.op-01234567890123456.example.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

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

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

    /// outposts arn with region mismatch and UseArnRegion=true
    #[test]
    fn test_219() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .force_path_style(false)
            .use_arn_region(true)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// outposts arn with region mismatch and UseArnRegion unset
    #[test]
    fn test_220() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .force_path_style(false)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// outposts arn with partition mismatch and UseArnRegion=true
    #[test]
    fn test_221() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .bucket("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .force_path_style(false)
            .use_arn_region(true)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but ARN (`arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint`) has `aws-cn` [outposts arn with partition mismatch and UseArnRegion=true]");
        assert_eq!(format!("{}", error), "Client was configured for partition `aws` but ARN (`arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint`) has `aws-cn`")
    }

    /// ARN with UseGlobalEndpoint and use-east-1 region uses the regional endpoint
    #[test]
    fn test_222() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_global_endpoint(true)
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

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

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

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

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

    /// validates against access point host label
    #[test]
    fn test_227() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:invalid.bucket#".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `invalid.bucket#` [validates against access point host label]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `invalid.bucket#`"
        )
    }

    /// object lambda @us-east-1
    #[test]
    fn test_228() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(false)
            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// object lambda @us-west-2
    #[test]
    fn test_229() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(false)
            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// object lambda, colon resource deliminator @us-west-2
    #[test]
    fn test_230() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(false)
            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// object lambda @us-east-1, client region us-west-2, useArnRegion=true
    #[test]
    fn test_231() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(true)
            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=true
    #[test]
    fn test_232() {
        let params = crate::config::endpoint::Params::builder()
            .region("s3-external-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(true)
            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

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

    /// object lambda @us-east-1, client region aws-global, useArnRegion=true
    #[test]
    fn test_234() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(true)
            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

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

    /// object lambda @cn-north-1, client region us-west-2 (cross partition), useArnRegion=true
    #[test]
    fn test_236() {
        let params = crate::config::endpoint::Params::builder()
            .region("aws-global".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(true)
            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but ARN (`arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner`) has `aws-cn` [object lambda @cn-north-1, client region us-west-2 (cross partition), useArnRegion=true]");
        assert_eq!(format!("{}", error), "Client was configured for partition `aws` but ARN (`arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner`) has `aws-cn`")
    }

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

    /// object lambda @us-gov-east-1
    #[test]
    fn test_238() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-gov-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(false)
            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-gov-east-1".to_string())
                )
                .build()
        );
    }

    /// object lambda @us-gov-east-1, with fips
    #[test]
    fn test_239() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-gov-east-1".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(false)
            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-gov-east-1".to_string())
                )
                .build()
        );
    }

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

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

    /// object lambda with invalid arn - bad service and someresource
    #[test]
    fn test_242() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(false)
            .bucket("arn:aws:sqs:us-west-2:123456789012:someresource".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: Unrecognized format: arn:aws:sqs:us-west-2:123456789012:someresource (type: someresource) [object lambda with invalid arn - bad service and someresource]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: Unrecognized format: arn:aws:sqs:us-west-2:123456789012:someresource (type: someresource)"
        )
    }

    /// object lambda with invalid arn - invalid resource
    #[test]
    fn test_243() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(false)
            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:bucket_name:mybucket".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `bucket_name` [object lambda with invalid arn - invalid resource]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `bucket_name`"
        )
    }

    /// object lambda with invalid arn - missing region
    #[test]
    fn test_244() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(false)
            .bucket("arn:aws:s3-object-lambda::123456789012:accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Invalid ARN: bucket ARN is missing a region [object lambda with invalid arn - missing region]");
        assert_eq!(format!("{}", error), "Invalid ARN: bucket ARN is missing a region")
    }

    /// object lambda with invalid arn - missing account-id
    #[test]
    fn test_245() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(true)
            .bucket("arn:aws:s3-object-lambda:us-west-2::accesspoint/mybanner".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: Missing account id [object lambda with invalid arn - missing account-id]");
        assert_eq!(format!("{}", error), "Invalid ARN: Missing account id")
    }

    /// object lambda with invalid arn - account id contains invalid characters
    #[test]
    fn test_246() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(true)
            .bucket("arn:aws:s3-object-lambda:us-west-2:123.45678.9012:accesspoint:mybucket".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123.45678.9012` [object lambda with invalid arn - account id contains invalid characters]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123.45678.9012`"
        )
    }

    /// object lambda with invalid arn - missing access point name
    #[test]
    fn test_247() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(true)
            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided [object lambda with invalid arn - missing access point name]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
        )
    }

    /// object lambda with invalid arn - access point name contains invalid character: *
    #[test]
    fn test_248() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(true)
            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:*".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `*` [object lambda with invalid arn - access point name contains invalid character: *]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `*`"
        )
    }

    /// object lambda with invalid arn - access point name contains invalid character: .
    #[test]
    fn test_249() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(true)
            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:my.bucket".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `my.bucket` [object lambda with invalid arn - access point name contains invalid character: .]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `my.bucket`"
        )
    }

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

    /// object lambda with custom endpoint
    #[test]
    fn test_251() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_arn_region(false)
            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
            .endpoint("https://my-endpoint.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.my-endpoint.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybanner-123456789012.my-endpoint.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

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

    /// WriteGetObjectResponse @ us-west-2
    #[test]
    fn test_253() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .use_object_lambda_endpoint(true)
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-object-lambda.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// WriteGetObjectResponse with custom endpoint
    #[test]
    fn test_254() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .use_object_lambda_endpoint(true)
            .endpoint("https://my-endpoint.com".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://my-endpoint.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .build()
        );
    }

    /// WriteGetObjectResponse @ us-east-1
    #[test]
    fn test_255() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .use_object_lambda_endpoint(true)
            .region("us-east-1".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-object-lambda.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// WriteGetObjectResponse with fips
    #[test]
    fn test_256() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .use_object_lambda_endpoint(true)
            .region("us-east-1".to_string())
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-object-lambda-fips.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

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

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

    /// WriteGetObjectResponse with fips in CN
    #[test]
    fn test_259() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .region("cn-north-1".to_string())
            .use_object_lambda_endpoint(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Partition does not support FIPS [WriteGetObjectResponse with fips in CN]");
        assert_eq!(format!("{}", error), "Partition does not support FIPS")
    }

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

    /// WriteGetObjectResponse with an unknown partition
    #[test]
    fn test_261() {
        let params = crate::config::endpoint::Params::builder()
            .accelerate(false)
            .use_object_lambda_endpoint(true)
            .region("us-east.special".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east.special.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-object-lambda.us-east.special.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-object-lambda".to_string())
                        .put("signingRegion", "us-east.special".to_string())
                )
                .build()
        );
    }

    /// S3 Outposts bucketAlias Real Outpost Prod us-west-1
    #[test]
    fn test_262() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-1".to_string())
            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.us-west-1.amazonaws.com");
        assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.us-west-1.amazonaws.com")
    .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
    .put("disableDoubleEncoding", true)
    .put("signingName", "s3-outposts".to_string())
    .put("signingRegionSet", vec!["*".to_string().into()])
    )
    .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
    .put("disableDoubleEncoding", true)
    .put("signingName", "s3-outposts".to_string())
    .put("signingRegion", "us-west-1".to_string())
    )
    .build());
    }

    /// S3 Outposts bucketAlias Real Outpost Prod ap-east-1
    #[test]
    fn test_263() {
        let params = crate::config::endpoint::Params::builder()
            .region("ap-east-1".to_string())
            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com");
        assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com")
    .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
    .put("disableDoubleEncoding", true)
    .put("signingName", "s3-outposts".to_string())
    .put("signingRegionSet", vec!["*".to_string().into()])
    )
    .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
    .put("disableDoubleEncoding", true)
    .put("signingName", "s3-outposts".to_string())
    .put("signingRegion", "ap-east-1".to_string())
    )
    .build());
    }

    /// S3 Outposts bucketAlias Ec2 Outpost Prod us-east-1
    #[test]
    fn test_264() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// S3 Outposts bucketAlias Ec2 Outpost Prod me-south-1
    #[test]
    fn test_265() {
        let params = crate::config::endpoint::Params::builder()
            .region("me-south-1".to_string())
            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "me-south-1".to_string())
                )
                .build()
        );
    }

    /// S3 Outposts bucketAlias Real Outpost Beta
    #[test]
    fn test_266() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
            .endpoint("https://example.amazonaws.com".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

    /// S3 Outposts bucketAlias Ec2 Outpost Beta
    #[test]
    fn test_267() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3".to_string())
            .endpoint("https://example.amazonaws.com".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegionSet", vec!["*".to_string().into()])
                )
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .build()
        );
    }

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

    /// S3 Outposts invalid bucket name
    #[test]
    fn test_269() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("test-accessp-o0b1de75431d83bebd/8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
            .endpoint("https://example.amazonaws.com".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Invalid Outposts Bucket alias - it must be a valid bucket name. [S3 Outposts invalid bucket name]");
        assert_eq!(format!("{}", error), "Invalid Outposts Bucket alias - it must be a valid bucket name.")
    }

    /// S3 Outposts bucketAlias Invalid hardware type
    #[test]
    fn test_270() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("test-accessp-h0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: Unrecognized hardware type: \"Expected hardware type o or e but got h\" [S3 Outposts bucketAlias Invalid hardware type]",
        );
        assert_eq!(
            format!("{}", error),
            "Unrecognized hardware type: \"Expected hardware type o or e but got h\""
        )
    }

    /// S3 Outposts bucketAlias Special character in Outpost Arn
    #[test]
    fn test_271() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("test-accessp-o00000754%1d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`. [S3 Outposts bucketAlias Special character in Outpost Arn]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`."
        )
    }

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

    /// S3 Snow with bucket
    #[test]
    fn test_273() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .bucket("bucketName".to_string())
            .endpoint("http://10.0.1.12:433".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12:433/bucketName");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://10.0.1.12:433/bucketName")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "snow".to_string())
                )
                .build()
        );
    }

    /// S3 Snow without bucket
    #[test]
    fn test_274() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .endpoint("https://10.0.1.12:433".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.1.12:433");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://10.0.1.12:433")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "snow".to_string())
                )
                .build()
        );
    }

    /// S3 Snow no port
    #[test]
    fn test_275() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .bucket("bucketName".to_string())
            .endpoint("http://10.0.1.12".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12/bucketName");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://10.0.1.12/bucketName")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "snow".to_string())
                )
                .build()
        );
    }

    /// S3 Snow dns endpoint
    #[test]
    fn test_276() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .bucket("bucketName".to_string())
            .endpoint("https://amazonaws.com".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://amazonaws.com/bucketName");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://amazonaws.com/bucketName")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3".to_string())
                        .put("signingRegion", "snow".to_string())
                )
                .build()
        );
    }

    /// Data Plane with short zone name
    #[test]
    fn test_277() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("mybucket--abcd-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short zone name china region
    #[test]
    fn test_278() {
        let params = crate::config::endpoint::Params::builder()
            .region("cn-north-1".to_string())
            .bucket("mybucket--abcd-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short zone name with AP
    #[test]
    fn test_279() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("myaccesspoint--abcd-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short zone name with AP china region
    #[test]
    fn test_280() {
        let params = crate::config::endpoint::Params::builder()
            .region("cn-north-1".to_string())
            .bucket("myaccesspoint--abcd-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short zone names (13 chars)
    #[test]
    fn test_281() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short zone names (13 chars) with AP
    #[test]
    fn test_282() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with medium zone names (14 chars)
    #[test]
    fn test_283() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with medium zone names (14 chars) with AP
    #[test]
    fn test_284() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long zone names (20 chars)
    #[test]
    fn test_285() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long zone names (20 chars)
    #[test]
    fn test_286() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short zone fips
    #[test]
    fn test_287() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("mybucket--test-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short zone fips china region
    #[test]
    fn test_288() {
        let params = crate::config::endpoint::Params::builder()
            .region("cn-north-1".to_string())
            .bucket("mybucket--test-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Data Plane with short zone fips china region]");
        assert_eq!(format!("{}", error), "Partition does not support FIPS")
    }

    /// Data Plane with short zone fips with AP
    #[test]
    fn test_289() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-ab1--xa-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test-ab1--xa-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short zone fips with AP china region
    #[test]
    fn test_290() {
        let params = crate::config::endpoint::Params::builder()
            .region("cn-north-1".to_string())
            .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Data Plane with short zone fips with AP china region]");
        assert_eq!(format!("{}", error), "Partition does not support FIPS")
    }

    /// Data Plane with short zone (13 chars) fips
    #[test]
    fn test_291() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short zone (13 chars) fips with AP
    #[test]
    fn test_292() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with medium zone (14 chars) fips
    #[test]
    fn test_293() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with medium zone (14 chars) fips with AP
    #[test]
    fn test_294() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long zone (20 chars) fips
    #[test]
    fn test_295() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long zone (20 chars) fips with AP
    #[test]
    fn test_296() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long AZ
    #[test]
    fn test_297() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long AZ with AP
    #[test]
    fn test_298() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long AZ fips
    #[test]
    fn test_299() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-az1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long AZ fips with AP
    #[test]
    fn test_300() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control plane with short AZ bucket
    #[test]
    fn test_301() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("mybucket--test-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control plane with short AZ bucket china region
    #[test]
    fn test_302() {
        let params = crate::config::endpoint::Params::builder()
            .region("cn-north-1".to_string())
            .bucket("mybucket--test-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.cn-north-1.amazonaws.com.cn/mybucket--test-ab1--x-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.cn-north-1.amazonaws.com.cn/mybucket--test-ab1--x-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control plane with short AZ bucket and fips
    #[test]
    fn test_303() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("mybucket--test-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control plane with short AZ bucket and fips china region
    #[test]
    fn test_304() {
        let params = crate::config::endpoint::Params::builder()
            .region("cn-north-1".to_string())
            .bucket("mybucket--test-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Control plane with short AZ bucket and fips china region]");
        assert_eq!(format!("{}", error), "Partition does not support FIPS")
    }

    /// Control plane without bucket
    #[test]
    fn test_305() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control plane without bucket and fips
    #[test]
    fn test_306() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control-fips.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short AZ
    #[test]
    fn test_307() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short AZ with AP
    #[test]
    fn test_308() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short zone (13 chars)
    #[test]
    fn test_309() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short zone (13 chars) with AP
    #[test]
    fn test_310() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short AZ fips
    #[test]
    fn test_311() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short AZ fips with AP
    #[test]
    fn test_312() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short zone (13 chars) fips
    #[test]
    fn test_313() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short zone (13 chars) fips with AP
    #[test]
    fn test_314() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long AZ
    #[test]
    fn test_315() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long AZ with AP
    #[test]
    fn test_316() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with medium zone(14 chars)
    #[test]
    fn test_317() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with medium zone(14 chars) with AP
    #[test]
    fn test_318() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long zone(20 chars)
    #[test]
    fn test_319() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long zone(20 chars) with AP
    #[test]
    fn test_320() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long AZ fips
    #[test]
    fn test_321() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-az1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long AZ fips with AP
    #[test]
    fn test_322() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with medium zone (14 chars) fips
    #[test]
    fn test_323() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with medium zone (14 chars) fips with AP
    #[test]
    fn test_324() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long zone (20 chars) fips
    #[test]
    fn test_325() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long zone (20 chars) fips with AP
    #[test]
    fn test_326() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control Plane host override
    #[test]
    fn test_327() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(true)
            .endpoint("https://custom.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az1--x-s3.custom.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control Plane host override with AP
    #[test]
    fn test_328() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(true)
            .endpoint("https://custom.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.custom.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az1--xa-s3.custom.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control Plane host override no bucket
    #[test]
    fn test_329() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(true)
            .endpoint("https://custom.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://custom.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://custom.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data plane host override non virtual session auth
    #[test]
    fn test_330() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .endpoint("https://10.0.0.1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data plane host override non virtual session auth with AP
    #[test]
    fn test_331() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .endpoint("https://10.0.0.1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control Plane host override ip
    #[test]
    fn test_332() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(true)
            .endpoint("https://10.0.0.1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control Plane host override ip with AP
    #[test]
    fn test_333() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(true)
            .endpoint("https://10.0.0.1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data plane host override
    #[test]
    fn test_334() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .endpoint("https://custom.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az1--x-s3.custom.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data plane host override with AP
    #[test]
    fn test_335() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .endpoint("https://custom.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.custom.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az1--xa-s3.custom.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

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

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

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

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

    /// accelerate error
    #[test]
    fn test_340() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("mybucket--test-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(true)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
    }

    /// accelerate error with AP
    #[test]
    fn test_341() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(true)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error with AP]");
        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
    }

    /// Data plane bucket format error
    #[test]
    fn test_342() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("my.bucket--test-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
    }

    /// Data plane AP format error
    #[test]
    fn test_343() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("my.myaccesspoint--test-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane AP format error]");
        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
    }

    /// host override data plane bucket error session auth
    #[test]
    fn test_344() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("my.bucket--usw2-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .endpoint("https://custom.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
        );
        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
    }

    /// host override data plane AP error session auth
    #[test]
    fn test_345() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .endpoint("https://custom.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error session auth]",
        );
        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
    }

    /// host override data plane bucket error
    #[test]
    fn test_346() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("my.bucket--usw2-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .endpoint("https://custom.com".to_string())
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint
            .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error]");
        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
    }

    /// host override data plane AP error
    #[test]
    fn test_347() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .endpoint("https://custom.com".to_string())
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error]");
        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
    }

    /// Control plane without bucket and dualstack
    #[test]
    fn test_348() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control plane without bucket, fips and dualstack
    #[test]
    fn test_349() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with bucket containing delimiters
    #[test]
    fn test_350() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("my--s3--bucket--abcd-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://my--s3--bucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://my--s3--bucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control plane with with bucket containing delimiters
    #[test]
    fn test_351() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("my--s3--bucket--abcd-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .disable_s3_express_session_auth(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/my--s3--bucket--abcd-ab1--x-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.us-east-1.amazonaws.com/my--s3--bucket--abcd-ab1--x-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short AZ and dualstack
    #[test]
    fn test_352() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with short AZ and FIPS with dualstack
    #[test]
    fn test_353() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short AZ and dualstack
    #[test]
    fn test_354() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with short AZ and FIPS with dualstack
    #[test]
    fn test_355() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with zone and dualstack
    #[test]
    fn test_356() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az12--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with zone and FIPS with dualstack
    #[test]
    fn test_357() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az12--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with zone and dualstack
    #[test]
    fn test_358() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az12--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with 9-char zone and FIPS with dualstack
    #[test]
    fn test_359() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--usw2-az12--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with 13-char zone and dualstack
    #[test]
    fn test_360() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with 13-char zone and FIPS with dualstack
    #[test]
    fn test_361() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with 13-char zone and dualstack
    #[test]
    fn test_362() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with 13-char zone and FIPS with dualstack
    #[test]
    fn test_363() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with 14-char zone and dualstack
    #[test]
    fn test_364() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with 14-char zone and FIPS with dualstack
    #[test]
    fn test_365() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with 14-char zone and dualstack
    #[test]
    fn test_366() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with 14-char zone and FIPS with dualstack
    #[test]
    fn test_367() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long zone (20 cha) and dualstack
    #[test]
    fn test_368() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with long zone (20 char) and FIPS with dualstack
    #[test]
    fn test_369() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long zone (20 char) and dualstack
    #[test]
    fn test_370() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with long zone (20 char) and FIPS with dualstack
    #[test]
    fn test_371() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control plane and FIPS with dualstack
    #[test]
    fn test_372() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("mybucket--test-ab1--x-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data plane with zone and dualstack and AP
    #[test]
    fn test_373() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data plane with zone and FIPS with dualstack and AP
    #[test]
    fn test_374() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with zone and dualstack and AP
    #[test]
    fn test_375() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane AP sigv4 auth with zone and FIPS with dualstack
    #[test]
    fn test_376() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with zone (9 char) and AP with dualstack
    #[test]
    fn test_377() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with zone (9 char) and FIPS with AP and dualstack
    #[test]
    fn test_378() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with (9 char) zone and dualstack with AP
    #[test]
    fn test_379() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Access Point sigv4 auth with (9 char) zone and FIPS with dualstack
    #[test]
    fn test_380() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with zone (13 char) and AP with dualstack
    #[test]
    fn test_381() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with zone (13 char) and AP with FIPS and dualstack
    #[test]
    fn test_382() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with (13 char) zone with AP and dualstack
    #[test]
    fn test_383() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint
            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with (13 char) zone with AP and FIPS and dualstack
    #[test]
    fn test_384() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with (14 char) zone and AP with dualstack
    #[test]
    fn test_385() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with (14 char) zone and AP with FIPS and dualstack
    #[test]
    fn test_386() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane sigv4 auth with (14 char) zone and AP with dualstack
    #[test]
    fn test_387() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with (14 char) zone and AP with FIPS and dualstack
    #[test]
    fn test_388() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect(
            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
        );
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with (20 char) zone and AP with dualstack
    #[test]
    fn test_389() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data Plane with (20 char) zone and AP with FIPS and dualstack
    #[test]
    fn test_390() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data plane AP with sigv4 and dualstack
    #[test]
    fn test_391() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Data plane AP sigv4 with fips and dualstack
    #[test]
    fn test_392() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-west-2".to_string())
            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
            .use_fips(true)
            .use_dual_stack(true)
            .accelerate(false)
            .disable_s3_express_session_auth(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-west-2".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }

    /// Control plane with dualstack and bucket
    #[test]
    fn test_393() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .bucket("mybucket--test-ab1--x-s3".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .accelerate(false)
            .use_s3_express_control_endpoint(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint =
            endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3express".to_string())
                        .put("signingRegion", "us-east-1".to_string())
                )
                .property("backend", "S3Express".to_string())
                .build()
        );
    }
}

/// Endpoint resolver trait specific to Amazon Simple Storage Service
pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
    /// Resolve an endpoint with the given parameters
    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;

    /// Convert this service-specific resolver into a `SharedEndpointResolver`
    ///
    /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
    fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
    where
        Self: Sized + 'static,
    {
        ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
    }
}

#[derive(Debug)]
struct DowncastParams<T>(T);
impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
where
    T: ResolveEndpoint,
{
    fn resolve_endpoint<'a>(
        &'a self,
        params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
    ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
        let ep = match params.get::<crate::config::endpoint::Params>() {
            Some(params) => self.0.resolve_endpoint(params),
            None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
        };
        ep
    }
}

#[derive(Debug)]
/// The default endpoint resolver.
pub struct DefaultResolver {
    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()
    }
}

impl DefaultResolver {
    /// Create a new DefaultResolver
    pub fn new() -> Self {
        Self {
            partition_resolver: &crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER,
            endpoint_cache: ::arc_swap::ArcSwap::from_pointee(None),
        }
    }

    #[allow(
        unused_variables,
        unused_parens,
        clippy::double_parens,
        clippy::useless_conversion,
        clippy::bool_comparison,
        clippy::comparison_to_empty,
        clippy::needless_borrow,
        clippy::useless_asref,
        clippy::redundant_closure_call,
        clippy::clone_on_copy
    )]
    fn resolve_endpoint<'a>(
        &'a self,
        params: &'a crate::config::endpoint::Params,
    ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
        let mut _diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
        #[allow(unused_mut)]
        let mut context = ConditionContext::default();

        // Param bindings
        let bucket = &params.bucket;
        let region = &params.region;
        let use_fips = &params.use_fips;
        let use_dual_stack = &params.use_dual_stack;
        let endpoint = &params.endpoint;
        let force_path_style = &params.force_path_style;
        let accelerate = &params.accelerate;
        let use_global_endpoint = &params.use_global_endpoint;
        let use_object_lambda_endpoint = &params.use_object_lambda_endpoint;
        let key = &params.key;
        let prefix = &params.prefix;
        let copy_source = &params.copy_source;
        let disable_access_points = &params.disable_access_points;
        let disable_multi_region_access_points = &params.disable_multi_region_access_points;
        let use_arn_region = &params.use_arn_region;
        let use_s3_express_control_endpoint = &params.use_s3_express_control_endpoint;
        let disable_s3_express_session_auth = &params.disable_s3_express_session_auth;

        let mut current_ref: i32 = 2;
        loop {
            match current_ref {
                ref_val if ref_val >= 100_000_000 => {
                    return match (ref_val - 100_000_000) as usize {
                        0 => ::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 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Accelerate cannot be used with FIPS".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        2 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Cannot set dual-stack in combination with a custom endpoint.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        3 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "A custom endpoint cannot be combined with FIPS".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        4 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "A custom endpoint cannot be combined with S3 Accelerate".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        5 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Partition does not support FIPS".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        6 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3Express does not support S3 Accelerate.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        7 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .property("backend", "S3Express".to_string())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3express")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        8 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .property("backend", "S3Express".to_string())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3express")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        9 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3Express bucket name is not a valid virtual hostable name.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        10 => {
                            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 s3_e_ds = context.s3_e_ds.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let s3_e_fips = context.s3_e_fips.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3express-control");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&s3_e_fips.as_ref());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&s3_e_ds.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .property("backend", "S3Express".to_string())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3express")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        11 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let s3_e_ds = context.s3_e_ds.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let s3_e_fips = context.s3_e_fips.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let s3express_availability_zone_id = context
                                .s3express_availability_zone_id
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3express");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&s3_e_fips.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&s3express_availability_zone_id.as_ref());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&s3_e_ds.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .property("backend", "S3Express".to_string())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3express")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        12 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Unrecognized S3Express bucket name format.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        13 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .property("backend", "S3Express".to_string())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3express")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        14 => {
                            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 s3_e_ds = context.s3_e_ds.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let s3_e_fips = context.s3_e_fips.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3express-control");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&s3_e_fips.as_ref());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&s3_e_ds.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .property("backend", "S3Express".to_string())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3express")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        15 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Expected a endpoint to be specified but no endpoint was found".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        16 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".ec2.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
                                    )
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        17 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".ec2.s3-outposts.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
                                    )
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        18 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".op-");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&outpost_id_ssa_2.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
                                    )
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        19 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".op-");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&outpost_id_ssa_2.as_ref());
                                        out.push_str(".s3-outposts.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
                                    )
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        20 => {
                            let hardware_type = context.hardware_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Unrecognized hardware type: \"Expected hardware type o or e but got ");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&hardware_type.as_ref());
                                out.push('"');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        21 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid Outposts Bucket alias - it must be a valid bucket name.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        22 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        23 => {
                            let endpoint = params.endpoint.as_deref().unwrap_or_default();
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Custom endpoint `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&endpoint.as_ref());
                                out.push_str("` was not a valid URI");
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        24 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 Accelerate cannot be used in this region".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        25 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3-fips.dualstack.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        26 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3-fips.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        27 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3-fips.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        28 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        29 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3-accelerate.dualstack.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        30 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3-accelerate.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        31 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3.dualstack.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        32 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        33 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.normalized_path());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        34 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        35 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.normalized_path());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        36 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        37 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3-accelerate.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        38 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3-accelerate.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        39 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        40 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        41 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket.as_ref());
                                        out.push_str(".s3.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        42 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid region: region was not a valid DNS name.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        43 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 Object Lambda does not support Dual-stack".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        44 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 Object Lambda does not support S3 Accelerate".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        45 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Access points are not supported for this operation".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        46 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid configuration: region from ARN `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket_arn.region());
                                out.push_str("` does not match client region `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&region.as_ref());
                                out.push_str("` and UseArnRegion is `false`");
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        47 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: Missing account id".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        48 => {
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_1.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-object-lambda")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        49 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_1.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push_str(".s3-object-lambda-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_partition.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-object-lambda")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        50 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_1.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push_str(".s3-object-lambda.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_partition.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-object-lambda")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        51 => {
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&access_point_name_ssa_1.as_ref());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        52 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket_arn.account_id());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        53 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid region in ARN: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket_arn.region());
                                out.push_str("` (invalid DNS name)");
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        54 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Client was configured for partition `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&partition_result.name());
                                out.push_str("` but ARN (`");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket.as_ref());
                                out.push_str("`) has `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket_partition.name());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        55 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        56 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: bucket ARN is missing a region".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        57 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        58 => {
                            let arn_type = context.arn_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&arn_type.as_ref());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        59 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Access Points do not support S3 Accelerate".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        60 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_1.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push_str(".s3-accesspoint-fips.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_partition.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        61 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_1.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push_str(".s3-accesspoint-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_partition.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        62 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_1.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push_str(".s3-accesspoint.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_partition.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        63 => {
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_1.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        64 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_1.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push_str(".s3-accesspoint.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_partition.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        65 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: The ARN was not for the S3 service, found: ");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket_arn.service());
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        66 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 MRAP does not support dual-stack".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        67 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 MRAP does not support FIPS".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        68 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 MRAP does not support S3 Accelerate".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        69 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid configuration: Multi-Region Access Point ARNs are disabled.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        70 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_1 = context
                                .access_point_name_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_1.as_ref());
                                        out.push_str(".accesspoint.s3-global.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
                                    )
                                    .build(),
                            )
                        }
                        71 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Client was configured for partition `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&partition_result.name());
                                out.push_str("` but bucket referred to partition `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket_arn.partition());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        72 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid Access Point Name".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        73 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 Outposts does not support Dual-stack".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        74 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 Outposts does not support FIPS".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        75 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 Outposts does not support S3 Accelerate".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        76 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid Arn: Outpost Access Point ARN contains sub resources".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        77 => {
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_2 = context
                                .access_point_name_ssa_2
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_2.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&outpost_id_ssa_1.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
                                    )
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        78 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_name_ssa_2 = context
                                .access_point_name_ssa_2
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_name_ssa_2.as_ref());
                                        out.push('-');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.account_id());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&outpost_id_ssa_1.as_ref());
                                        out.push_str(".s3-outposts.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_partition.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
                                    )
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        79 => {
                            let access_point_name_ssa_2 = context
                                .access_point_name_ssa_2
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&access_point_name_ssa_2.as_ref());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        80 => {
                            let outpost_type = context.outpost_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Expected an outpost type `accesspoint`, found ");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&outpost_type.as_ref());
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        81 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: expected an access point name".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        82 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: Expected a 4-component resource".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        83 => {
                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&outpost_id_ssa_1.as_ref());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        84 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: The Outpost Id was not set".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        85 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            let arn_type = context.arn_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: Unrecognized format: ");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket.as_ref());
                                out.push_str(" (type: ");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&arn_type.as_ref());
                                out.push(')');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        86 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: No ARN type specified".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        87 => {
                            let bucket = params.bucket.as_deref().unwrap_or_default();
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket.as_ref());
                                out.push_str("` was not a valid ARN");
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        88 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Path-style addressing cannot be used with ARN buckets".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        89 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-fips.dualstack.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        90 => {
                            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 uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-fips.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        91 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-fips.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        92 => {
                            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 uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-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.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        93 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.dualstack.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        94 => {
                            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 uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        95 => {
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.normalized_path());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        96 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.normalized_path());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        97 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        98 => {
                            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 uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        99 => {
                            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 uri_encoded_bucket = context
                                .uri_encoded_bucket
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out.push('/');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&uri_encoded_bucket.as_ref());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        100 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Path-style addressing cannot be used with S3 Accelerate".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        101 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-object-lambda")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        102 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-object-lambda-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-object-lambda")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        103 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-object-lambda.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-object-lambda")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        104 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-fips.dualstack.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        105 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-fips.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        106 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-fips.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        107 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        108 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.dualstack.us-east-1.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        109 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        110 => {
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        111 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        112 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", "us-east-1"),
                                    )
                                    .build(),
                            )
                        }
                        113 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        114 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        115 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "A region must be set when sending requests to S3.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        _ => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "No endpoint rule matched",
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                    };
                }
                1 | -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 {
                        0 => region.is_some(),
                        1 => (accelerate) == (&true),
                        2 => (use_fips) == (&true),
                        3 => (use_dual_stack) == (&true),
                        4 => endpoint.is_some(),
                        5 => bucket.is_some(),
                        6 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    0,
                                    6,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--x-s3")
                        })(&mut _diagnostic_collector),
                        7 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    0,
                                    7,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--xa-s3")
                        })(&mut _diagnostic_collector),
                        8 => (|_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),
                        9 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_suffix = &mut context.access_point_suffix;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *access_point_suffix = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    0,
                                    7,
                                    true,
                                    _diagnostic_collector,
                                )
                                .map(|inner| inner.into());
                                access_point_suffix.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        10 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_suffix = &context.access_point_suffix;
                            let partition_resolver = &self.partition_resolver;
                            (access_point_suffix) == &mut Some(("--op-s3".to_string().into()))
                        })(&mut _diagnostic_collector),
                        11 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let region_prefix = &mut context.region_prefix;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *region_prefix = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    8,
                                    12,
                                    true,
                                    _diagnostic_collector,
                                )
                                .map(|inner| inner.into());
                                region_prefix.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        12 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *outpost_id_ssa_2 = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    32,
                                    49,
                                    true,
                                    _diagnostic_collector,
                                )
                                .map(|inner| inner.into());
                                outpost_id_ssa_2.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        13 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let hardware_type = &mut context.hardware_type;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *hardware_type = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    49,
                                    50,
                                    true,
                                    _diagnostic_collector,
                                )
                                .map(|inner| inner.into());
                                hardware_type.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        14 => (force_path_style) == (&true),
                        15 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_result = &context.partition_result;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = partition_result {
                                inner.name()
                            } else {
                                return false;
                            }) == ("aws-cn")
                        })(&mut _diagnostic_collector),
                        16 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let s3_e_ds = &mut context.s3_e_ds;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *s3_e_ds = Some(crate::endpoint_lib::ite::ite!(use_dual_stack, ".dualstack".to_string(), "".to_string()).into());
                                true
                            }
                        })(&mut _diagnostic_collector),
                        17 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let outpost_id_ssa_2 = &context.outpost_id_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(param) = outpost_id_ssa_2 { param } else { return false },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        18 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let s3_e_fips = &mut context.s3_e_fips;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *s3_e_fips = Some(crate::endpoint_lib::ite::ite!(use_fips, "-fips".to_string(), "".to_string()).into());
                                true
                            }
                        })(&mut _diagnostic_collector),
                        19 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let s3_e_auth = &mut context.s3_e_auth;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *s3_e_auth = Some(
                                    crate::endpoint_lib::ite::ite!(
                                        crate::endpoint_lib::coalesce::coalesce!(disable_s3_express_session_auth.clone(), false),
                                        "sigv4".to_string(),
                                        "sigv4-s3express".to_string()
                                    )
                                    .into(),
                                );
                                true
                            }
                        })(&mut _diagnostic_collector),
                        20 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
                                if let Some(param) = bucket { param } else { return false },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        21 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let url = &mut context.url;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *url = crate::endpoint_lib::parse_url::parse_url(
                                    if let Some(param) = endpoint { param } else { return false },
                                    _diagnostic_collector,
                                )
                                .map(|inner| inner.into());
                                url.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        22 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(use_s3_express_control_endpoint.clone(), false)) == (true)
                        })(&mut _diagnostic_collector),
                        23 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
                                if let Some(param) = bucket { param } else { return false },
                                true,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        24 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let url = &context.url;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = url { inner.scheme() } else { return false }) == ("http")
                        })(&mut _diagnostic_collector),
                        25 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(param) = region { param } else { return false },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        26 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &mut context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *bucket_arn = crate::endpoint_lib::arn::parse_arn(
                                    if let Some(param) = bucket { param } else { return false },
                                    _diagnostic_collector,
                                )
                                .map(|inner| inner.into());
                                bucket_arn.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        27 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *s3express_availability_zone_id = crate::endpoint_lib::split::split(
                                    if let Some(param) = bucket { param } else { return false },
                                    "--",
                                    0,
                                    _diagnostic_collector,
                                )
                                .iter()
                                .nth_back(1)
                                .cloned()
                                .map(|inner| inner.into());
                                s3express_availability_zone_id.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        28 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    0,
                                    4,
                                    false,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("arn:")
                        })(&mut _diagnostic_collector),
                        29 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    16,
                                    18,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        30 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let url = &context.url;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = url { inner.is_ip() } else { return false }) == (true)
                        })(&mut _diagnostic_collector),
                        31 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    21,
                                    23,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        32 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    27,
                                    29,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        33 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let region_prefix = &context.region_prefix;
                            let partition_resolver = &self.partition_resolver;
                            (region_prefix) == &mut Some(("beta".to_string().into()))
                        })(&mut _diagnostic_collector),
                        34 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let uri_encoded_bucket = &mut context.uri_encoded_bucket;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *uri_encoded_bucket = Some(
                                    crate::endpoint_lib::uri_encode::uri_encode(
                                        if let Some(param) = bucket { param } else { return false },
                                        _diagnostic_collector,
                                    )
                                    .into(),
                                );
                                true
                            }
                        })(&mut _diagnostic_collector),
                        35 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(param) = region { param } else { return false },
                                true,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        36 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(use_object_lambda_endpoint.clone(), false)) == (true)
                        })(&mut _diagnostic_collector),
                        37 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let arn_type = &mut context.arn_type;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *arn_type = if let Some(inner) = bucket_arn {
                                    inner.resource_id().first().cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                arn_type.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        38 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let arn_type = &context.arn_type;
                            let partition_resolver = &self.partition_resolver;
                            (arn_type) == &mut Some(("".to_string().into()))
                        })(&mut _diagnostic_collector),
                        39 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let arn_type = &context.arn_type;
                            let partition_resolver = &self.partition_resolver;
                            (arn_type) == &mut Some(("accesspoint".to_string().into()))
                        })(&mut _diagnostic_collector),
                        40 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *access_point_name_ssa_1 = if let Some(inner) = bucket_arn {
                                    inner.resource_id().get(1).cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                access_point_name_ssa_1.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        41 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_name_ssa_1 = &context.access_point_name_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            (access_point_name_ssa_1) == &mut Some(("".to_string().into()))
                        })(&mut _diagnostic_collector),
                        42 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = bucket_arn { inner.region() } else { return false }) == ("")
                        })(&mut _diagnostic_collector),
                        43 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    14,
                                    16,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        44 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let hardware_type = &context.hardware_type;
                            let partition_resolver = &self.partition_resolver;
                            (hardware_type) == &mut Some(("e".to_string().into()))
                        })(&mut _diagnostic_collector),
                        45 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let hardware_type = &context.hardware_type;
                            let partition_resolver = &self.partition_resolver;
                            (hardware_type) == &mut Some(("o".to_string().into()))
                        })(&mut _diagnostic_collector),
                        46 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (region) == &mut Some(("aws-global".to_string().into()))
                        })(&mut _diagnostic_collector),
                        47 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    19,
                                    21,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        48 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-object-lambda")
                        })(&mut _diagnostic_collector),
                        49 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(disable_access_points.clone(), false)) == (true)
                        })(&mut _diagnostic_collector),
                        50 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-outposts")
                        })(&mut _diagnostic_collector),
                        51 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let bucket_partition = &mut context.bucket_partition;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *bucket_partition = partition_resolver
                                    .resolve_partition(
                                        if let Some(inner) = bucket_arn { inner.region() } else { return false },
                                        _diagnostic_collector,
                                    )
                                    .map(|inner| inner.into());
                                bucket_partition.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        52 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_name_ssa_1 = &context.access_point_name_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(param) = access_point_name_ssa_1 {
                                    param
                                } else {
                                    return false;
                                },
                                true,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        53 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    26,
                                    28,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        54 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    15,
                                    17,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        55 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            if let Some(inner) = bucket_arn {
                                inner.resource_id().get(4).cloned()
                            } else {
                                return false;
                            }
                            .is_some()
                        })(&mut _diagnostic_collector),
                        56 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = bucket { param } else { return false },
                                    20,
                                    22,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        57 => (use_global_endpoint) == (&true),
                        58 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (region) == &mut Some(("us-east-1".to_string().into()))
                        })(&mut _diagnostic_collector),
                        59 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *outpost_id_ssa_1 = if let Some(inner) = bucket_arn {
                                    inner.resource_id().get(1).cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                outpost_id_ssa_1.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        60 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(use_arn_region.clone(), true)) == (true)
                        })(&mut _diagnostic_collector),
                        61 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let outpost_id_ssa_1 = &context.outpost_id_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(param) = outpost_id_ssa_1 { param } else { return false },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        62 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let outpost_type = &mut context.outpost_type;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *outpost_type = if let Some(inner) = bucket_arn {
                                    inner.resource_id().get(2).cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                outpost_type.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        63 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            (region) == &mut Some((if let Some(inner) = bucket_arn { inner.region() } else { return false }.into()))
                        })(&mut _diagnostic_collector),
                        64 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_result = &context.partition_result;
                            let bucket_partition = &context.bucket_partition;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = bucket_partition {
                                inner.name()
                            } else {
                                return false;
                            }) == (if let Some(inner) = partition_result {
                                inner.name()
                            } else {
                                return false;
                            })
                        })(&mut _diagnostic_collector),
                        65 => (disable_multi_region_access_points) == (&true),
                        66 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(inner) = bucket_arn { inner.region() } else { return false },
                                true,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        67 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_result = &context.partition_result;
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = bucket_arn { inner.partition() } else { return false })
                                == (if let Some(inner) = partition_result {
                                    inner.name()
                                } else {
                                    return false;
                                })
                        })(&mut _diagnostic_collector),
                        68 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = bucket_arn {
                                inner.account_id()
                            } else {
                                return false;
                            }) == ("")
                        })(&mut _diagnostic_collector),
                        69 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3")
                        })(&mut _diagnostic_collector),
                        70 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(inner) = bucket_arn {
                                    inner.account_id()
                                } else {
                                    return false;
                                },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        71 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *access_point_name_ssa_2 = if let Some(inner) = bucket_arn {
                                    inner.resource_id().get(3).cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                access_point_name_ssa_2.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        72 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_name_ssa_1 = &context.access_point_name_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(param) = access_point_name_ssa_1 {
                                    param
                                } else {
                                    return false;
                                },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        73 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let outpost_type = &context.outpost_type;
                            let partition_resolver = &self.partition_resolver;
                            (outpost_type) == &mut Some(("accesspoint".to_string().into()))
                        })(&mut _diagnostic_collector),
                        74 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_name_ssa_2 = &context.access_point_name_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(param) = access_point_name_ssa_2 {
                                    param
                                } else {
                                    return false;
                                },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        _ => unreachable!("Invalid condition index"),
                    };
                    current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };
                }
            }
        }
    }
}

impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
        // Check single-entry cache (lock-free read via ArcSwap)
        let cached = self.endpoint_cache.load();
        if let Some((cached_params, cached_endpoint)) = cached.as_ref() {
            if cached_params == params {
                return ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(::std::result::Result::Ok(cached_endpoint.clone()));
            }
        }
        drop(cached);
        let result = self.resolve_endpoint(params);
        if let ::std::result::Result::Ok(ref endpoint) = result {
            self.endpoint_cache.store(::std::sync::Arc::new(Some((params.clone(), endpoint.clone()))));
        }
        ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(result)
    }
}
const NODES: [crate::endpoint_lib::bdd_interpreter::BddNode; 553] = [
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: -1,
        high_ref: 1,
        low_ref: -1,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 0,
        high_ref: 3,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 1,
        high_ref: 424,
        low_ref: 4,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 2,
        high_ref: 272,
        low_ref: 5,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 3,
        high_ref: 233,
        low_ref: 6,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 4,
        high_ref: 85,
        low_ref: 7,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 5,
        high_ref: 15,
        low_ref: 8,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 9,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 10,
        low_ref: 13,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 11,
        low_ref: 13,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 12,
        low_ref: 13,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 100000014,
        low_ref: 13,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 14,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000103,
        low_ref: 435,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 6,
        high_ref: 271,
        low_ref: 16,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 7,
        high_ref: 270,
        low_ref: 17,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 19,
        low_ref: 18,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 501,
        low_ref: 106,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 9,
        high_ref: 20,
        low_ref: 24,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 10,
        high_ref: 21,
        low_ref: 24,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 22,
        low_ref: 24,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 23,
        low_ref: 24,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 547,
        low_ref: 24,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 77,
        low_ref: 25,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 73,
        low_ref: 26,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 27,
        low_ref: 78,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 28,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 29,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 47,
        low_ref: 30,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000058,
        low_ref: 31,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 32,
        low_ref: 100000085,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 33,
        low_ref: 136,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 55,
        high_ref: 100000076,
        low_ref: 34,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 59,
        high_ref: 35,
        low_ref: 100000084,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 39,
        low_ref: 36,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 61,
        high_ref: 37,
        low_ref: 100000083,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 38,
        low_ref: 146,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 41,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 61,
        high_ref: 40,
        low_ref: 100000083,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 41,
        low_ref: 150,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 42,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 43,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 44,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 71,
        high_ref: 45,
        low_ref: 100000081,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 73,
        high_ref: 46,
        low_ref: 100000080,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 74,
        high_ref: 100000078,
        low_ref: 100000079,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 48,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 49,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 185,
        low_ref: 50,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 62,
        low_ref: 51,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 52,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 53,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 56,
        low_ref: 54,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 55,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 57,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 57,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 58,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 59,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 69,
        high_ref: 60,
        low_ref: 100000065,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 61,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 72,
        high_ref: 100000064,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 63,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 64,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 67,
        low_ref: 65,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 66,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 68,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 68,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 69,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 70,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 68,
        high_ref: 100000047,
        low_ref: 71,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 72,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 72,
        high_ref: 100000050,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 74,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000039,
        low_ref: 75,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 57,
        high_ref: 76,
        low_ref: 100000041,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 58,
        high_ref: 100000040,
        low_ref: 100000041,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000088,
        low_ref: 78,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 100000087,
        low_ref: 79,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 82,
        low_ref: 80,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 81,
        low_ref: 545,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000103,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000097,
        low_ref: 83,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 57,
        high_ref: 84,
        low_ref: 100000099,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 58,
        high_ref: 100000098,
        low_ref: 100000099,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 5,
        high_ref: 101,
        low_ref: 86,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 87,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 88,
        low_ref: 89,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 91,
        low_ref: 89,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 90,
        low_ref: 92,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 97,
        low_ref: 95,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 93,
        low_ref: 92,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 98,
        low_ref: 95,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 97,
        low_ref: 94,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 100000014,
        low_ref: 95,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 96,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000103,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 100000013,
        low_ref: 98,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 99,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000101,
        low_ref: 100,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000110,
        low_ref: 100000111,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 6,
        high_ref: 214,
        low_ref: 102,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 7,
        high_ref: 208,
        low_ref: 103,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 119,
        low_ref: 104,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 118,
        low_ref: 105,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 106,
        low_ref: 100000023,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 107,
        low_ref: 502,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 108,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 109,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 112,
        low_ref: 110,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000058,
        low_ref: 111,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 136,
        low_ref: 100000085,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 113,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 114,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 115,
        low_ref: 500,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000056,
        low_ref: 116,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 117,
        low_ref: 100000072,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 65,
        high_ref: 100000069,
        low_ref: 100000072,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 501,
        low_ref: 100000023,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 9,
        high_ref: 120,
        low_ref: 124,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 10,
        high_ref: 121,
        low_ref: 124,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 122,
        low_ref: 124,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 123,
        low_ref: 124,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 202,
        low_ref: 124,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 195,
        low_ref: 125,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 190,
        low_ref: 126,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 127,
        low_ref: 100000023,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 128,
        low_ref: 129,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 189,
        low_ref: 129,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 130,
        low_ref: 197,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 131,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 132,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 159,
        low_ref: 133,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000058,
        low_ref: 134,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 135,
        low_ref: 100000085,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 141,
        low_ref: 136,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 55,
        high_ref: 100000076,
        low_ref: 137,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 59,
        high_ref: 138,
        low_ref: 100000084,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 100000083,
        low_ref: 139,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 61,
        high_ref: 140,
        low_ref: 100000083,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 100000083,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 55,
        high_ref: 100000076,
        low_ref: 142,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 59,
        high_ref: 143,
        low_ref: 100000084,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 148,
        low_ref: 144,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 61,
        high_ref: 145,
        low_ref: 100000083,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 147,
        low_ref: 146,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 150,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 153,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 61,
        high_ref: 149,
        low_ref: 100000083,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 153,
        low_ref: 150,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 151,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 152,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 100000082,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 154,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 155,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 156,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 71,
        high_ref: 157,
        low_ref: 100000081,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 73,
        high_ref: 158,
        low_ref: 100000080,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 74,
        high_ref: 100000077,
        low_ref: 100000079,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 160,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 161,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 185,
        low_ref: 162,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 174,
        low_ref: 163,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 164,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 165,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 168,
        low_ref: 166,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 167,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 169,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 169,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 170,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 171,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 69,
        high_ref: 172,
        low_ref: 100000065,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 173,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 72,
        high_ref: 100000063,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 175,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 176,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 179,
        low_ref: 177,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 178,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 180,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 180,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 181,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 182,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 68,
        high_ref: 100000047,
        low_ref: 183,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 184,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 72,
        high_ref: 100000048,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000056,
        low_ref: 186,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 187,
        low_ref: 100000072,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 65,
        high_ref: 100000069,
        low_ref: 188,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 67,
        high_ref: 100000070,
        low_ref: 100000071,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 100000036,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 191,
        low_ref: 100000023,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 192,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 194,
        low_ref: 193,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000034,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000033,
        low_ref: 100000035,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 196,
        low_ref: 100000023,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000088,
        low_ref: 197,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 100000087,
        low_ref: 198,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 201,
        low_ref: 199,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 200,
        low_ref: 545,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000101,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000095,
        low_ref: 100000096,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 17,
        high_ref: 203,
        low_ref: 100000022,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 204,
        low_ref: 100000021,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 205,
        low_ref: 550,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 206,
        low_ref: 550,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 44,
        high_ref: 100000016,
        low_ref: 207,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 45,
        high_ref: 100000018,
        low_ref: 100000020,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 209,
        low_ref: 215,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 210,
        low_ref: 220,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 211,
        low_ref: 220,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 212,
        low_ref: 224,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 213,
        low_ref: 227,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 231,
        low_ref: 401,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 218,
        low_ref: 215,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 216,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 217,
        low_ref: 227,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 231,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 219,
        low_ref: 220,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 223,
        low_ref: 220,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 221,
        low_ref: 224,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 222,
        low_ref: 227,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 231,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 226,
        low_ref: 224,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 225,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 100000009,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 230,
        low_ref: 227,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 228,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 229,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 100000007,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 231,
        low_ref: 415,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 232,
        low_ref: 100000008,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 100000007,
        low_ref: 100000008,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 4,
        high_ref: 100000002,
        low_ref: 234,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 5,
        high_ref: 235,
        low_ref: 480,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 6,
        high_ref: 271,
        low_ref: 236,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 7,
        high_ref: 270,
        low_ref: 237,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 238,
        low_ref: 491,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 9,
        high_ref: 239,
        low_ref: 243,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 10,
        high_ref: 240,
        low_ref: 243,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 241,
        low_ref: 243,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 242,
        low_ref: 243,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 547,
        low_ref: 243,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 266,
        low_ref: 244,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 264,
        low_ref: 245,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 246,
        low_ref: 267,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 247,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 248,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 249,
        low_ref: 518,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 250,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 251,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 538,
        low_ref: 252,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000043,
        low_ref: 253,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 254,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 255,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 258,
        low_ref: 256,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 257,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 259,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 259,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 260,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 261,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 69,
        high_ref: 262,
        low_ref: 100000065,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 263,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 72,
        high_ref: 100000062,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 265,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000031,
        low_ref: 100000032,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000088,
        low_ref: 267,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 100000087,
        low_ref: 268,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 269,
        low_ref: 544,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000093,
        low_ref: 100000094,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 397,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 407,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 3,
        high_ref: 346,
        low_ref: 273,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 4,
        high_ref: 100000003,
        low_ref: 274,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 5,
        high_ref: 284,
        low_ref: 275,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 276,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 100000005,
        low_ref: 277,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 278,
        low_ref: 281,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 279,
        low_ref: 281,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 280,
        low_ref: 281,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 100000014,
        low_ref: 281,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 282,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000102,
        low_ref: 283,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000106,
        low_ref: 100000107,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 6,
        high_ref: 405,
        low_ref: 285,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 7,
        high_ref: 395,
        low_ref: 286,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 295,
        low_ref: 287,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 501,
        low_ref: 288,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 289,
        low_ref: 502,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 290,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 291,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 292,
        low_ref: 307,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 293,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 294,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 335,
        low_ref: 500,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 9,
        high_ref: 296,
        low_ref: 300,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 10,
        high_ref: 297,
        low_ref: 300,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 298,
        low_ref: 300,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 299,
        low_ref: 300,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 394,
        low_ref: 300,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 339,
        low_ref: 301,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 100000005,
        low_ref: 302,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 337,
        low_ref: 303,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 304,
        low_ref: 341,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 305,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 306,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 309,
        low_ref: 307,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000058,
        low_ref: 308,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 100000074,
        low_ref: 100000085,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 310,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 311,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 335,
        low_ref: 312,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 324,
        low_ref: 313,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 314,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 315,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 318,
        low_ref: 316,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 317,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 319,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 319,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 320,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 321,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 69,
        high_ref: 322,
        low_ref: 100000065,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 323,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 72,
        high_ref: 100000061,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 325,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 326,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 329,
        low_ref: 327,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 328,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 330,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 330,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 331,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 332,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 68,
        high_ref: 100000047,
        low_ref: 333,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 334,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 72,
        high_ref: 100000049,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000056,
        low_ref: 336,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 100000067,
        low_ref: 100000072,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 338,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000027,
        low_ref: 100000028,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 100000005,
        low_ref: 340,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000088,
        low_ref: 341,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 100000087,
        low_ref: 342,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 345,
        low_ref: 343,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 344,
        low_ref: 545,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000102,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000091,
        low_ref: 100000092,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 4,
        high_ref: 100000002,
        low_ref: 347,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 5,
        high_ref: 357,
        low_ref: 348,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 349,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 100000005,
        low_ref: 350,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 351,
        low_ref: 354,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 352,
        low_ref: 354,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 353,
        low_ref: 354,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 100000014,
        low_ref: 354,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 355,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000043,
        low_ref: 356,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000104,
        low_ref: 100000105,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 6,
        high_ref: 405,
        low_ref: 358,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 7,
        high_ref: 395,
        low_ref: 359,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 360,
        low_ref: 491,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 9,
        high_ref: 361,
        low_ref: 365,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 10,
        high_ref: 362,
        low_ref: 365,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 363,
        low_ref: 365,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 364,
        low_ref: 365,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 394,
        low_ref: 365,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 389,
        low_ref: 366,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 100000005,
        low_ref: 367,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 387,
        low_ref: 368,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 369,
        low_ref: 391,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 370,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 371,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 372,
        low_ref: 518,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 373,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 374,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 538,
        low_ref: 375,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000043,
        low_ref: 376,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 377,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 378,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 381,
        low_ref: 379,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 380,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 382,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 382,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 383,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 384,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 69,
        high_ref: 385,
        low_ref: 100000065,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 386,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 72,
        high_ref: 100000060,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 388,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000025,
        low_ref: 100000026,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 100000005,
        low_ref: 390,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000088,
        low_ref: 391,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 100000087,
        low_ref: 392,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 393,
        low_ref: 544,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000089,
        low_ref: 100000090,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 100000005,
        low_ref: 547,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 396,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 100000005,
        low_ref: 397,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 398,
        low_ref: 410,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 399,
        low_ref: 410,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 400,
        low_ref: 410,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 401,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 402,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 29,
        high_ref: 100000011,
        low_ref: 403,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 31,
        high_ref: 100000011,
        low_ref: 404,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 32,
        high_ref: 100000011,
        low_ref: 422,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 406,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 100000005,
        low_ref: 407,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 408,
        low_ref: 410,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 409,
        low_ref: 410,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 411,
        low_ref: 410,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 100000012,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 414,
        low_ref: 412,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 413,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 100000010,
        low_ref: 100000009,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 416,
        low_ref: 415,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 419,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 418,
        low_ref: 417,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 100000010,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 100000010,
        low_ref: 419,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 43,
        high_ref: 100000011,
        low_ref: 420,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 47,
        high_ref: 100000011,
        low_ref: 421,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 53,
        high_ref: 100000011,
        low_ref: 422,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 54,
        high_ref: 100000011,
        low_ref: 423,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 56,
        high_ref: 100000011,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 2,
        high_ref: 100000001,
        low_ref: 425,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 3,
        high_ref: 478,
        low_ref: 426,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 4,
        high_ref: 100000004,
        low_ref: 427,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 5,
        high_ref: 438,
        low_ref: 428,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 429,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 430,
        low_ref: 433,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 431,
        low_ref: 433,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 432,
        low_ref: 433,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 100000014,
        low_ref: 433,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 434,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000044,
        low_ref: 435,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000112,
        low_ref: 436,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 57,
        high_ref: 437,
        low_ref: 100000114,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 58,
        high_ref: 100000113,
        low_ref: 100000114,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 6,
        high_ref: 100000006,
        low_ref: 439,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 7,
        high_ref: 100000006,
        low_ref: 440,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 450,
        low_ref: 441,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 501,
        low_ref: 442,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 443,
        low_ref: 502,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 444,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 445,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 446,
        low_ref: 465,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 447,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 448,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 471,
        low_ref: 449,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000044,
        low_ref: 500,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 9,
        high_ref: 451,
        low_ref: 455,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 10,
        high_ref: 452,
        low_ref: 455,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 453,
        low_ref: 455,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 454,
        low_ref: 455,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 547,
        low_ref: 455,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 473,
        low_ref: 456,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 460,
        low_ref: 457,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 458,
        low_ref: 461,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 459,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000037,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 540,
        low_ref: 461,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 462,
        low_ref: 474,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 463,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 464,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 467,
        low_ref: 465,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000058,
        low_ref: 466,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 100000075,
        low_ref: 100000085,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 468,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 469,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 471,
        low_ref: 470,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000044,
        low_ref: 524,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000044,
        low_ref: 472,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 100000068,
        low_ref: 100000072,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000088,
        low_ref: 474,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 100000087,
        low_ref: 475,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 100000100,
        low_ref: 476,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 477,
        low_ref: 545,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000044,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 4,
        high_ref: 100000002,
        low_ref: 479,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 5,
        high_ref: 488,
        low_ref: 480,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 481,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 482,
        low_ref: 485,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 483,
        low_ref: 485,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 484,
        low_ref: 485,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 100000014,
        low_ref: 485,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 486,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000043,
        low_ref: 487,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000108,
        low_ref: 100000109,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 6,
        high_ref: 100000006,
        low_ref: 489,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 7,
        high_ref: 100000006,
        low_ref: 490,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 503,
        low_ref: 491,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 501,
        low_ref: 492,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 493,
        low_ref: 502,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 494,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 495,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 496,
        low_ref: 518,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 497,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 498,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 538,
        low_ref: 499,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000043,
        low_ref: 500,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000088,
        low_ref: 502,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 100000087,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 9,
        high_ref: 504,
        low_ref: 508,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 10,
        high_ref: 505,
        low_ref: 508,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 506,
        low_ref: 508,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 507,
        low_ref: 508,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 547,
        low_ref: 508,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 541,
        low_ref: 509,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 513,
        low_ref: 510,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 511,
        low_ref: 514,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 512,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000029,
        low_ref: 100000030,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 540,
        low_ref: 514,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 515,
        low_ref: 542,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 516,
        low_ref: 100000086,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 100000086,
        low_ref: 517,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 520,
        low_ref: 518,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000058,
        low_ref: 519,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 100000073,
        low_ref: 100000085,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 521,
        low_ref: 100000057,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000057,
        low_ref: 522,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 538,
        low_ref: 523,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000043,
        low_ref: 524,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 100000045,
        low_ref: 525,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 529,
        low_ref: 526,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 100000055,
        low_ref: 527,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 528,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 100000055,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 532,
        low_ref: 530,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 531,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 533,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000055,
        low_ref: 533,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 534,
        low_ref: 100000054,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 535,
        low_ref: 100000053,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 69,
        high_ref: 536,
        low_ref: 100000065,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 70,
        high_ref: 537,
        low_ref: 100000052,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 72,
        high_ref: 100000059,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000043,
        low_ref: 539,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 100000066,
        low_ref: 100000072,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 100000024,
        low_ref: 100000042,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000088,
        low_ref: 542,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 100000087,
        low_ref: 543,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 100000100,
        low_ref: 544,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 546,
        low_ref: 545,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000042,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 100000043,
        low_ref: 100000115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 17,
        high_ref: 548,
        low_ref: 100000022,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 549,
        low_ref: 100000021,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 552,
        low_ref: 550,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 44,
        high_ref: 100000017,
        low_ref: 551,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 45,
        high_ref: 100000019,
        low_ref: 100000020,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 44,
        high_ref: 100000015,
        low_ref: 553,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 45,
        high_ref: 100000015,
        low_ref: 100000020,
    },
];
// 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) access_point_suffix: Option<::std::string::String>,
    pub(crate) region_prefix: Option<::std::string::String>,
    pub(crate) outpost_id_ssa_2: Option<::std::string::String>,
    pub(crate) hardware_type: Option<::std::string::String>,
    pub(crate) s3_e_ds: Option<::std::string::String>,
    pub(crate) s3_e_fips: Option<::std::string::String>,
    pub(crate) s3_e_auth: Option<::std::string::String>,
    pub(crate) url: Option<crate::endpoint_lib::parse_url::Url<'a>>,
    pub(crate) bucket_arn: Option<crate::endpoint_lib::arn::Arn<'a>>,
    pub(crate) s3express_availability_zone_id: ::std::option::Option<::std::string::String>,
    pub(crate) uri_encoded_bucket: Option<::std::string::String>,
    pub(crate) arn_type: ::std::option::Option<::std::string::String>,
    pub(crate) access_point_name_ssa_1: ::std::option::Option<::std::string::String>,
    pub(crate) bucket_partition: Option<crate::endpoint_lib::partition::Partition<'a>>,
    pub(crate) outpost_id_ssa_1: ::std::option::Option<::std::string::String>,
    pub(crate) outpost_type: ::std::option::Option<::std::string::String>,
    pub(crate) access_point_name_ssa_2: ::std::option::Option<::std::string::String>,
    // Sometimes none of the members reference the lifetime, this makes it still valid
    phantom: std::marker::PhantomData<&'a ()>,
}

#[non_exhaustive]
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
/// Configuration parameters for resolving the correct endpoint
pub struct Params {
    /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
    pub(crate) bucket: ::std::option::Option<::std::string::String>,
    /// The AWS region used to dispatch the request.
    pub(crate) region: ::std::option::Option<::std::string::String>,
    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
    pub(crate) use_fips: bool,
    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
    pub(crate) use_dual_stack: bool,
    /// Override the endpoint used to send this request
    pub(crate) endpoint: ::std::option::Option<::std::string::String>,
    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
    pub(crate) force_path_style: bool,
    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
    pub(crate) accelerate: bool,
    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
    pub(crate) use_global_endpoint: bool,
    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
    pub(crate) use_object_lambda_endpoint: ::std::option::Option<bool>,
    /// The S3 Key used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Key.
    pub(crate) key: ::std::option::Option<::std::string::String>,
    /// The S3 Prefix used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Prefix.
    pub(crate) prefix: ::std::option::Option<::std::string::String>,
    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
    pub(crate) copy_source: ::std::option::Option<::std::string::String>,
    /// Internal parameter to disable Access Point Buckets
    pub(crate) disable_access_points: ::std::option::Option<bool>,
    /// Whether multi-region access points (MRAP) should be disabled.
    pub(crate) disable_multi_region_access_points: bool,
    /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
    pub(crate) use_arn_region: ::std::option::Option<bool>,
    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
    pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
    /// Parameter to indicate whether S3Express session auth should be disabled
    pub(crate) disable_s3_express_session_auth: ::std::option::Option<bool>,
}
impl Params {
    /// Create a builder for [`Params`]
    pub fn builder() -> crate::config::endpoint::ParamsBuilder {
        crate::config::endpoint::ParamsBuilder::default()
    }
    /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
    pub fn bucket(&self) -> ::std::option::Option<&str> {
        self.bucket.as_deref()
    }
    /// The AWS region used to dispatch the request.
    pub fn region(&self) -> ::std::option::Option<&str> {
        self.region.as_deref()
    }
    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
    pub fn use_fips(&self) -> ::std::option::Option<bool> {
        Some(self.use_fips)
    }
    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
    pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
        Some(self.use_dual_stack)
    }
    /// Override the endpoint used to send this request
    pub fn endpoint(&self) -> ::std::option::Option<&str> {
        self.endpoint.as_deref()
    }
    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
    pub fn force_path_style(&self) -> ::std::option::Option<bool> {
        Some(self.force_path_style)
    }
    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
    pub fn accelerate(&self) -> ::std::option::Option<bool> {
        Some(self.accelerate)
    }
    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
    pub fn use_global_endpoint(&self) -> ::std::option::Option<bool> {
        Some(self.use_global_endpoint)
    }
    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
    pub fn use_object_lambda_endpoint(&self) -> ::std::option::Option<bool> {
        self.use_object_lambda_endpoint
    }
    /// The S3 Key used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Key.
    pub fn key(&self) -> ::std::option::Option<&str> {
        self.key.as_deref()
    }
    /// The S3 Prefix used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Prefix.
    pub fn prefix(&self) -> ::std::option::Option<&str> {
        self.prefix.as_deref()
    }
    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
    pub fn copy_source(&self) -> ::std::option::Option<&str> {
        self.copy_source.as_deref()
    }
    /// Internal parameter to disable Access Point Buckets
    pub fn disable_access_points(&self) -> ::std::option::Option<bool> {
        self.disable_access_points
    }
    /// Whether multi-region access points (MRAP) should be disabled.
    pub fn disable_multi_region_access_points(&self) -> ::std::option::Option<bool> {
        Some(self.disable_multi_region_access_points)
    }
    /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
    pub fn use_arn_region(&self) -> ::std::option::Option<bool> {
        self.use_arn_region
    }
    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
    pub fn use_s3_express_control_endpoint(&self) -> ::std::option::Option<bool> {
        self.use_s3_express_control_endpoint
    }
    /// Parameter to indicate whether S3Express session auth should be disabled
    pub fn disable_s3_express_session_auth(&self) -> ::std::option::Option<bool> {
        self.disable_s3_express_session_auth
    }
}

/// Builder for [`Params`]
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
pub struct ParamsBuilder {
    bucket: ::std::option::Option<::std::string::String>,
    region: ::std::option::Option<::std::string::String>,
    use_fips: ::std::option::Option<bool>,
    use_dual_stack: ::std::option::Option<bool>,
    endpoint: ::std::option::Option<::std::string::String>,
    force_path_style: ::std::option::Option<bool>,
    accelerate: ::std::option::Option<bool>,
    use_global_endpoint: ::std::option::Option<bool>,
    use_object_lambda_endpoint: ::std::option::Option<bool>,
    key: ::std::option::Option<::std::string::String>,
    prefix: ::std::option::Option<::std::string::String>,
    copy_source: ::std::option::Option<::std::string::String>,
    disable_access_points: ::std::option::Option<bool>,
    disable_multi_region_access_points: ::std::option::Option<bool>,
    use_arn_region: ::std::option::Option<bool>,
    use_s3_express_control_endpoint: ::std::option::Option<bool>,
    disable_s3_express_session_auth: ::std::option::Option<bool>,
}
impl ParamsBuilder {
    /// Consume this builder, creating [`Params`].
    pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
        Ok(
            #[allow(clippy::unnecessary_lazy_evaluations)]
            crate::config::endpoint::Params {
                bucket: self.bucket,
                region: self.region,
                use_fips: self
                    .use_fips
                    .or_else(|| Some(false))
                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_fips"))?,
                use_dual_stack: self
                    .use_dual_stack
                    .or_else(|| Some(false))
                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?,
                endpoint: self.endpoint,
                force_path_style: self
                    .force_path_style
                    .or_else(|| Some(false))
                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("force_path_style"))?,
                accelerate: self
                    .accelerate
                    .or_else(|| Some(false))
                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("accelerate"))?,
                use_global_endpoint: self
                    .use_global_endpoint
                    .or_else(|| Some(false))
                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_global_endpoint"))?,
                use_object_lambda_endpoint: self.use_object_lambda_endpoint,
                key: self.key,
                prefix: self.prefix,
                copy_source: self.copy_source,
                disable_access_points: self.disable_access_points,
                disable_multi_region_access_points: self
                    .disable_multi_region_access_points
                    .or_else(|| Some(false))
                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("disable_multi_region_access_points"))?,
                use_arn_region: self.use_arn_region,
                use_s3_express_control_endpoint: self.use_s3_express_control_endpoint,
                disable_s3_express_session_auth: self.disable_s3_express_session_auth,
            },
        )
    }
    /// Sets the value for bucket
    ///
    /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
    pub fn bucket(mut self, value: impl Into<::std::string::String>) -> Self {
        self.bucket = Some(value.into());
        self
    }

    /// Sets the value for bucket
    ///
    /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
    pub fn set_bucket(mut self, param: Option<::std::string::String>) -> Self {
        self.bucket = param;
        self
    }
    /// Sets the value for region
    ///
    /// The AWS region used to dispatch the request.
    pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
        self.region = Some(value.into());
        self
    }

    /// Sets the value for region
    ///
    /// The AWS region used to dispatch the request.
    pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
        self.region = param;
        self
    }
    /// Sets the value for use_fips
    ///
    /// When unset, this parameter has a default value of `false`.
    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
    pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
        self.use_fips = Some(value.into());
        self
    }

    /// Sets the value for use_fips
    ///
    /// When unset, this parameter has a default value of `false`.
    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
    pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
        self.use_fips = param;
        self
    }
    /// Sets the value for use_dual_stack
    ///
    /// When unset, this parameter has a default value of `false`.
    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
    pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
        self.use_dual_stack = Some(value.into());
        self
    }

    /// Sets the value for use_dual_stack
    ///
    /// When unset, this parameter has a default value of `false`.
    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
    pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
        self.use_dual_stack = param;
        self
    }
    /// Sets the value for endpoint
    ///
    /// Override the endpoint used to send this request
    pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
        self.endpoint = Some(value.into());
        self
    }

    /// Sets the value for endpoint
    ///
    /// Override the endpoint used to send this request
    pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
        self.endpoint = param;
        self
    }
    /// Sets the value for force_path_style
    ///
    /// When unset, this parameter has a default value of `false`.
    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
    pub fn force_path_style(mut self, value: impl Into<bool>) -> Self {
        self.force_path_style = Some(value.into());
        self
    }

    /// Sets the value for force_path_style
    ///
    /// When unset, this parameter has a default value of `false`.
    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
    pub fn set_force_path_style(mut self, param: Option<bool>) -> Self {
        self.force_path_style = param;
        self
    }
    /// Sets the value for accelerate
    ///
    /// When unset, this parameter has a default value of `false`.
    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
    pub fn accelerate(mut self, value: impl Into<bool>) -> Self {
        self.accelerate = Some(value.into());
        self
    }

    /// Sets the value for accelerate
    ///
    /// When unset, this parameter has a default value of `false`.
    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
    pub fn set_accelerate(mut self, param: Option<bool>) -> Self {
        self.accelerate = param;
        self
    }
    /// Sets the value for use_global_endpoint
    ///
    /// When unset, this parameter has a default value of `false`.
    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
    pub fn use_global_endpoint(mut self, value: impl Into<bool>) -> Self {
        self.use_global_endpoint = Some(value.into());
        self
    }

    /// Sets the value for use_global_endpoint
    ///
    /// When unset, this parameter has a default value of `false`.
    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
    pub fn set_use_global_endpoint(mut self, param: Option<bool>) -> Self {
        self.use_global_endpoint = param;
        self
    }
    /// Sets the value for use_object_lambda_endpoint
    ///
    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
    pub fn use_object_lambda_endpoint(mut self, value: impl Into<bool>) -> Self {
        self.use_object_lambda_endpoint = Some(value.into());
        self
    }

    /// Sets the value for use_object_lambda_endpoint
    ///
    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
    pub fn set_use_object_lambda_endpoint(mut self, param: Option<bool>) -> Self {
        self.use_object_lambda_endpoint = param;
        self
    }
    /// Sets the value for key
    ///
    /// The S3 Key used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Key.
    pub fn key(mut self, value: impl Into<::std::string::String>) -> Self {
        self.key = Some(value.into());
        self
    }

    /// Sets the value for key
    ///
    /// The S3 Key used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Key.
    pub fn set_key(mut self, param: Option<::std::string::String>) -> Self {
        self.key = param;
        self
    }
    /// Sets the value for prefix
    ///
    /// The S3 Prefix used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Prefix.
    pub fn prefix(mut self, value: impl Into<::std::string::String>) -> Self {
        self.prefix = Some(value.into());
        self
    }

    /// Sets the value for prefix
    ///
    /// The S3 Prefix used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Prefix.
    pub fn set_prefix(mut self, param: Option<::std::string::String>) -> Self {
        self.prefix = param;
        self
    }
    /// Sets the value for copy_source
    ///
    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
    pub fn copy_source(mut self, value: impl Into<::std::string::String>) -> Self {
        self.copy_source = Some(value.into());
        self
    }

    /// Sets the value for copy_source
    ///
    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
    pub fn set_copy_source(mut self, param: Option<::std::string::String>) -> Self {
        self.copy_source = param;
        self
    }
    /// Sets the value for disable_access_points
    ///
    /// Internal parameter to disable Access Point Buckets
    pub fn disable_access_points(mut self, value: impl Into<bool>) -> Self {
        self.disable_access_points = Some(value.into());
        self
    }

    /// Sets the value for disable_access_points
    ///
    /// Internal parameter to disable Access Point Buckets
    pub fn set_disable_access_points(mut self, param: Option<bool>) -> Self {
        self.disable_access_points = param;
        self
    }
    /// Sets the value for disable_multi_region_access_points
    ///
    /// When unset, this parameter has a default value of `false`.
    /// Whether multi-region access points (MRAP) should be disabled.
    pub fn disable_multi_region_access_points(mut self, value: impl Into<bool>) -> Self {
        self.disable_multi_region_access_points = Some(value.into());
        self
    }

    /// Sets the value for disable_multi_region_access_points
    ///
    /// When unset, this parameter has a default value of `false`.
    /// Whether multi-region access points (MRAP) should be disabled.
    pub fn set_disable_multi_region_access_points(mut self, param: Option<bool>) -> Self {
        self.disable_multi_region_access_points = param;
        self
    }
    /// Sets the value for use_arn_region
    ///
    /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
    pub fn use_arn_region(mut self, value: impl Into<bool>) -> Self {
        self.use_arn_region = Some(value.into());
        self
    }

    /// Sets the value for use_arn_region
    ///
    /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
    pub fn set_use_arn_region(mut self, param: Option<bool>) -> Self {
        self.use_arn_region = param;
        self
    }
    /// Sets the value for use_s3_express_control_endpoint
    ///
    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
    pub fn use_s3_express_control_endpoint(mut self, value: impl Into<bool>) -> Self {
        self.use_s3_express_control_endpoint = Some(value.into());
        self
    }

    /// Sets the value for use_s3_express_control_endpoint
    ///
    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
    pub fn set_use_s3_express_control_endpoint(mut self, param: Option<bool>) -> Self {
        self.use_s3_express_control_endpoint = param;
        self
    }
    /// Sets the value for disable_s3_express_session_auth
    ///
    /// Parameter to indicate whether S3Express session auth should be disabled
    pub fn disable_s3_express_session_auth(mut self, value: impl Into<bool>) -> Self {
        self.disable_s3_express_session_auth = Some(value.into());
        self
    }

    /// Sets the value for disable_s3_express_session_auth
    ///
    /// Parameter to indicate whether S3Express session auth should be disabled
    pub fn set_disable_s3_express_session_auth(mut self, param: Option<bool>) -> Self {
        self.disable_s3_express_session_auth = param;
        self
    }
}

/// An error that occurred during endpoint resolution
#[derive(Debug)]
pub struct InvalidParams {
    field: std::borrow::Cow<'static, str>,
    kind: InvalidParamsErrorKind,
}

/// The kind of invalid parameter error
#[derive(Debug)]
enum InvalidParamsErrorKind {
    MissingField,
    InvalidValue { message: &'static str },
}

impl InvalidParams {
    #[allow(dead_code)]
    fn missing(field: &'static str) -> Self {
        Self {
            field: field.into(),
            kind: InvalidParamsErrorKind::MissingField,
        }
    }

    #[allow(dead_code)]
    fn invalid_value(field: &'static str, message: &'static str) -> Self {
        Self {
            field: field.into(),
            kind: InvalidParamsErrorKind::InvalidValue { message },
        }
    }
}

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),
        }
    }
}

impl std::error::Error for InvalidParams {}