aws-sdk-s3control 1.119.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 {

    /// Vanilla outposts without ARN region + access point ARN@us-west-2
    #[test]
    fn test_1() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-west-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// Vanilla outposts with ARN region + access point ARN@us-west-2
    #[test]
    fn test_2() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// accept an access point ARN@us-west-2
    #[test]
    fn test_3() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-west-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// vanilla outposts china@cn-north-1
    #[test]
    fn test_4() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("cn-north-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.cn-north-1.amazonaws.com.cn")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// gov region@us-west-2
    #[test]
    fn test_5() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-west-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// gov cloud with fips@us-west-2
    #[test]
    fn test_6() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-west-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// govcloud with fips + arn region@us-gov-west-1
    #[test]
    fn test_7() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string(),
            )
            .account_id("123456789012".to_string())
            .region("us-gov-west-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-gov-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-gov-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-gov-east-1".to_string())
                )
                .build()
        );
    }

    /// gov region@cn-north-1
    #[test]
    fn test_8() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("cn-north-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.cn-north-1.amazonaws.com.cn")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// gov cloud with fips@cn-north-1
    #[test]
    fn test_9() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("cn-north-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Partition does not support FIPS [gov cloud with fips@cn-north-1]");
        assert_eq!(format!("{}", error), "Partition does not support FIPS")
    }

    /// govcloud with fips + arn region@us-gov-west-1
    #[test]
    fn test_10() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string(),
            )
            .account_id("123456789012".to_string())
            .region("us-gov-west-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-gov-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-gov-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-gov-east-1".to_string())
                )
                .build()
        );
    }

    /// gov region@af-south-1
    #[test]
    fn test_11() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("af-south-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.af-south-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// gov cloud with fips@af-south-1
    #[test]
    fn test_12() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("af-south-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.af-south-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// govcloud with fips + arn region@us-gov-west-1
    #[test]
    fn test_13() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string(),
            )
            .account_id("123456789012".to_string())
            .region("us-gov-west-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-gov-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-gov-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-gov-east-1".to_string())
                )
                .build()
        );
    }

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

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

    /// CreateBucket without OutpostId = regular endpoint@us-east-2
    #[test]
    fn test_16() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("blah".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(false)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-control.us-east-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-control.us-east-2.amazonaws.com")
                .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()
        );
    }

    /// ListRegionalBuckets + OutpostId = outposts endpoint@us-east-2
    #[test]
    fn test_17() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .outpost_id("op-123".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-east-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-east-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// ListRegionalBuckets without OutpostId = regular endpoint@us-east-2
    #[test]
    fn test_18() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123456789012.s3-control.us-east-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123456789012.s3-control.us-east-2.amazonaws.com")
                .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()
        );
    }

    /// ListRegionalBucket + OutpostId with fips = outposts endpoint@us-east-2
    #[test]
    fn test_19() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .outpost_id("op-123".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-east-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-east-2.amazonaws.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// outpost access points support dualstack@us-west-2
    #[test]
    fn test_20() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-west-2.api.aws");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-west-2.api.aws")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// outpost access points support dualstack@af-south-1
    #[test]
    fn test_21() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("af-south-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.af-south-1.api.aws");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.af-south-1.api.aws")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// outpost access points support fips + dualstack@af-south-1
    #[test]
    fn test_22() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("af-south-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.af-south-1.api.aws");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.af-south-1.api.aws")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// invalid ARN: must be include outpost ID@us-west-2
    #[test]
    fn test_23() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Invalid ARN: The Outpost Id was not set [invalid ARN: must be include outpost ID@us-west-2]");
        assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
    }

    /// invalid ARN: must specify access point@us-west-2
    #[test]
    fn test_24() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Invalid ARN: Expected a 4-component resource [invalid ARN: must specify access point@us-west-2]");
        assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
    }

    /// invalid ARN@us-west-2
    #[test]
    fn test_25() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:myaccesspoint".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a 4-component resource [invalid ARN@us-west-2]");
        assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
    }

    /// when set, AccountId drives AP construction@us-west-2
    #[test]
    fn test_26() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("myaccesspoint".to_string())
            .account_id("myid-1234".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://myid-1234.s3-control.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://myid-1234.s3-control.us-west-2.amazonaws.com")
                .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()
        );
    }

    /// Account ID set inline and in ARN but they both match@us-west-2
    #[test]
    fn test_27() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_arn_region(false)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-west-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// Account ID set inline and in ARN and they do not match@us-west-2
    #[test]
    fn test_28() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("999999999999".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_arn_region(false)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: the accountId specified in the ARN (`123456789012`) does not match the parameter (`999999999999`) [Account ID set inline and in ARN and they do not match@us-west-2]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: the accountId specified in the ARN (`123456789012`) does not match the parameter (`999999999999`)"
        )
    }

    /// get access point prefixed with account id using endpoint url@us-west-2
    #[test]
    fn test_29() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("apname".to_string())
            .account_id("123456789012".to_string())
            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123456789012.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123456789012.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
                .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 url with s3-outposts@us-west-2
    #[test]
    fn test_30() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .endpoint("https://beta.example.com".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://beta.example.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// access point name with a bucket arn@us-west-2
    #[test]
    fn test_31() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .endpoint("beta.example.com".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint
            .expect_err("expected error: Expected an outpost type `accesspoint`, found `bucket` [access point name with a bucket arn@us-west-2]");
        assert_eq!(format!("{}", error), "Expected an outpost type `accesspoint`, found `bucket`")
    }

    /// bucket arn with access point name@us-west-2
    #[test]
    fn test_32() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .endpoint("beta.example.com".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: Invalid ARN: Expected an outpost type `bucket`, found `accesspoint` [bucket arn with access point name@us-west-2]",
        );
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: Expected an outpost type `bucket`, found `accesspoint`"
        )
    }

    /// create bucket with outposts@us-west-2
    #[test]
    fn test_33() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("bucketname".to_string())
            .endpoint("https://beta.example.com".to_string())
            .outpost_id("op-123".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(false)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://beta.example.com")
                .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()
        );
    }

    /// get bucket with endpoint_url@us-west-2
    #[test]
    fn test_34() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .endpoint("https://beta.example.com".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://beta.example.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// ListRegionalBucket + OutpostId endpoint url@us-east-2
    #[test]
    fn test_35() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .endpoint("https://beta.example.com".to_string())
            .outpost_id("op-123".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://beta.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// ListRegionalBucket + OutpostId + fips + endpoint url@us-east-2
    #[test]
    fn test_36() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .endpoint("https://beta.example.com".to_string())
            .outpost_id("op-123".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://beta.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// ListRegionalBucket + OutpostId + fips + dualstack@us-east-2
    #[test]
    fn test_37() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .outpost_id("op-123".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-east-2.api.aws");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-east-2.api.aws")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// CreateBucket + OutpostId endpoint url@us-east-2
    #[test]
    fn test_38() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("blah".to_string())
            .endpoint("https://beta.example.com".to_string())
            .outpost_id("123".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(false)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://beta.example.com")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// dualstack cannot be used with outposts when an endpoint URL is set@us-west-2.
    #[test]
    fn test_39() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .endpoint("https://s3-outposts.us-west-2.api.aws".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid Configuration: DualStack and custom endpoint are not supported [dualstack cannot be used with outposts when an endpoint URL is set@us-west-2.]");
        assert_eq!(
            format!("{}", error),
            "Invalid Configuration: DualStack and custom endpoint are not supported"
        )
    }

    /// vanilla bucket arn requires account id@us-west-2
    #[test]
    fn test_40() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-west-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// bucket arn with UseArnRegion = true (arn region supercedes client configured region)@us-west-2
    #[test]
    fn test_41() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// bucket ARN in gov partition (non-fips)@us-gov-east-1
    #[test]
    fn test_42() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-gov-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-gov-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-gov-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-gov-east-1".to_string())
                )
                .build()
        );
    }

    /// bucket ARN in gov partition with FIPS@us-gov-west-1
    #[test]
    fn test_43() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws-us-gov:s3-outposts:us-gov-west-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-gov-west-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-gov-west-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-gov-west-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-gov-west-1".to_string())
                )
                .build()
        );
    }

    /// bucket ARN in aws partition with FIPS@us-east-2
    #[test]
    fn test_44() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-east-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-east-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// bucket ARN in aws partition with fips + dualstack@us-east-2
    #[test]
    fn test_45() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-east-2.api.aws");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-east-2.api.aws")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// vanilla bucket arn requires account id@cn-north-1
    #[test]
    fn test_46() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("cn-north-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.cn-north-1.amazonaws.com.cn")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "cn-north-1".to_string())
                )
                .build()
        );
    }

    /// bucket arn with UseArnRegion = true (arn region supercedes client configured region)@us-west-2
    #[test]
    fn test_47() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// bucket ARN in gov partition (non-fips)@us-gov-east-1
    #[test]
    fn test_48() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-gov-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-gov-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-gov-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-gov-east-1".to_string())
                )
                .build()
        );
    }

    /// bucket ARN in gov partition with FIPS@us-gov-west-1
    #[test]
    fn test_49() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws-us-gov:s3-outposts:us-gov-west-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-gov-west-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-gov-west-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-gov-west-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-gov-west-1".to_string())
                )
                .build()
        );
    }

    /// bucket ARN in aws partition with FIPS@us-east-2
    #[test]
    fn test_50() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-east-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-east-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// Outposts support dualstack @us-west-2
    #[test]
    fn test_51() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-west-2.api.aws");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-west-2.api.aws")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// vanilla bucket arn requires account id@af-south-1
    #[test]
    fn test_52() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("af-south-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.af-south-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.af-south-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "af-south-1".to_string())
                )
                .build()
        );
    }

    /// bucket arn with UseArnRegion = true (arn region supercedes client configured region)@us-west-2
    #[test]
    fn test_53() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// bucket ARN in gov partition (non-fips)@us-gov-east-1
    #[test]
    fn test_54() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-gov-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-gov-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-gov-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-gov-east-1".to_string())
                )
                .build()
        );
    }

    /// bucket ARN in gov partition with FIPS@us-gov-west-1
    #[test]
    fn test_55() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws-us-gov:s3-outposts:us-gov-west-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-gov-west-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-gov-west-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-gov-west-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-gov-west-1".to_string())
                )
                .build()
        );
    }

    /// bucket ARN in aws partition with FIPS@us-east-2
    #[test]
    fn test_56() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts-fips.us-east-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts-fips.us-east-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .auth_scheme(
                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
                        .put("disableDoubleEncoding", true)
                        .put("signingName", "s3-outposts".to_string())
                        .put("signingRegion", "us-east-2".to_string())
                )
                .build()
        );
    }

    /// Invalid ARN: missing outpost id and bucket@us-west-2
    #[test]
    fn test_57() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: Invalid ARN: The Outpost Id was not set [Invalid ARN: missing outpost id and bucket@us-west-2]");
        assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
    }

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

    /// Invalid ARN: missing outpost and bucket ids@us-west-2
    #[test]
    fn test_59() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:bucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint
            .expect_err("expected error: Invalid ARN: Expected a 4-component resource [Invalid ARN: missing outpost and bucket ids@us-west-2]");
        assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
    }

    /// Invalid ARN: missing bucket id@us-west-2
    #[test]
    fn test_60() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: expected a bucket name [Invalid ARN: missing bucket id@us-west-2]");
        assert_eq!(format!("{}", error), "Invalid ARN: expected a bucket name")
    }

    /// account id inserted into hostname@us-west-2
    #[test]
    fn test_61() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("1234567890".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://1234567890.s3-control.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://1234567890.s3-control.us-west-2.amazonaws.com")
                .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()
        );
    }

    /// account id prefix with dualstack@us-east-1
    #[test]
    fn test_62() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("1234567890".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://1234567890.s3-control.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://1234567890.s3-control.dualstack.us-east-1.amazonaws.com")
                .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()
        );
    }

    /// account id prefix with fips@us-east-1
    #[test]
    fn test_63() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("1234567890".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://1234567890.s3-control-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://1234567890.s3-control-fips.us-east-1.amazonaws.com")
                .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()
        );
    }

    /// custom account id prefix with fips@us-east-1
    #[test]
    fn test_64() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123456789012.s3-control-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123456789012.s3-control-fips.us-east-1.amazonaws.com")
                .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()
        );
    }

    /// standard url @ us-east-1
    #[test]
    fn test_65() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-control.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-control.us-east-1.amazonaws.com")
                .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 url @ us-east-1
    #[test]
    fn test_66() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-control-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-control-fips.us-east-1.amazonaws.com")
                .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 url @ us-east-1
    #[test]
    fn test_67() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_dual_stack(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-control.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-control.dualstack.us-east-1.amazonaws.com")
                .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 url @ us-east-1
    #[test]
    fn test_68() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-control-fips.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-control-fips.dualstack.us-east-1.amazonaws.com")
                .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()
        );
    }

    /// standard url @ cn-north-1
    #[test]
    fn test_69() {
        let params = crate::config::endpoint::Params::builder()
            .region("cn-north-1".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-control.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-control.cn-north-1.amazonaws.com.cn")
                .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_70() {
        let params = crate::config::endpoint::Params::builder()
            .region("cn-north-1".to_string())
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Partition does not support FIPS [fips @ cn-north-1]");
        assert_eq!(format!("{}", error), "Partition does not support FIPS")
    }

    /// custom account id prefix @us-east-1
    #[test]
    fn test_71() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123456789012.s3-control.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123456789012.s3-control.us-east-1.amazonaws.com")
                .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()
        );
    }

    /// invalid account id prefix @us-east-1
    #[test]
    fn test_72() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("/?invalid&not-host*label".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: AccountId must only contain a-z, A-Z, 0-9 and `-`. [invalid account id prefix @us-east-1]");
        assert_eq!(format!("{}", error), "AccountId must only contain a-z, A-Z, 0-9 and `-`.")
    }

    /// custom account id prefix with fips@us-east-1
    #[test]
    fn test_73() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123456789012.s3-control-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123456789012.s3-control-fips.us-east-1.amazonaws.com")
                .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()
        );
    }

    /// custom account id prefix with dualstack,fips@us-east-1
    #[test]
    fn test_74() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123456789012.s3-control-fips.dualstack.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123456789012.s3-control-fips.dualstack.us-east-1.amazonaws.com")
                .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()
        );
    }

    /// custom account id with custom endpoint
    #[test]
    fn test_75() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .endpoint("https://example.com".to_string())
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123456789012.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123456789012.example.com")
                .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()
        );
    }

    /// RequiresAccountId with AccountId unset
    #[test]
    fn test_76() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: AccountId is required but not set [RequiresAccountId with AccountId unset]");
        assert_eq!(format!("{}", error), "AccountId is required but not set")
    }

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

    /// RequiresAccountId with invalid AccountId and custom endpoint
    #[test]
    fn test_78() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .endpoint("https://beta.example.com".to_string())
            .account_id("/?invalid&not-host*label".to_string())
            .requires_account_id(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: AccountId must only contain a-z, A-Z, 0-9 and `-`. [RequiresAccountId with invalid AccountId and custom endpoint]",
        );
        assert_eq!(format!("{}", error), "AccountId must only contain a-z, A-Z, 0-9 and `-`.")
    }

    /// account id with custom endpoint, fips
    #[test]
    fn test_79() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("123456789012".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .endpoint("https://example.com".to_string())
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123456789012.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123456789012.example.com")
                .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()
        );
    }

    /// custom endpoint, fips
    #[test]
    fn test_80() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .endpoint("https://example.com".to_string())
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://example.com")
                .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()
        );
    }

    /// custom endpoint, fips
    #[test]
    fn test_81() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .endpoint("https://example.com".to_string())
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://example.com")
                .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()
        );
    }

    /// custom endpoint, DualStack
    #[test]
    fn test_82() {
        let params = crate::config::endpoint::Params::builder()
            .region("us-east-1".to_string())
            .endpoint("https://example.com".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint
            .expect_err("expected error: Invalid Configuration: DualStack and custom endpoint are not supported [custom endpoint, DualStack]");
        assert_eq!(
            format!("{}", error),
            "Invalid Configuration: DualStack and custom endpoint are not supported"
        )
    }

    /// region not set
    #[test]
    fn test_83() {
        let params = crate::config::endpoint::Params::builder().build().expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Region must be set [region not set]");
        assert_eq!(format!("{}", error), "Region must be set")
    }

    /// invalid partition
    #[test]
    fn test_84() {
        let params = crate::config::endpoint::Params::builder()
            .region("invalid-region 42".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 partition]");
        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
    }

    /// ListRegionalBuckets + OutpostId without accountId set.
    #[test]
    fn test_85() {
        let params = crate::config::endpoint::Params::builder()
            .outpost_id("op-123".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: AccountId is required but not set [ListRegionalBuckets + OutpostId without accountId set.]");
        assert_eq!(format!("{}", error), "AccountId is required but not set")
    }

    /// ListRegionalBuckets + OutpostId with invalid accountId set.
    #[test]
    fn test_86() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("/?invalid&not-host*label".to_string())
            .outpost_id("op-123".to_string())
            .region("us-east-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: AccountId must only contain a-z, A-Z, 0-9 and `-`. [ListRegionalBuckets + OutpostId with invalid accountId set.]",
        );
        assert_eq!(format!("{}", error), "AccountId must only contain a-z, A-Z, 0-9 and `-`.")
    }

    /// accesspoint set but missing accountId
    #[test]
    fn test_87() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("myaccesspoint".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: AccountId is required but not set [accesspoint set but missing accountId]");
        assert_eq!(format!("{}", error), "AccountId is required but not set")
    }

    /// outpost accesspoint ARN with missing accountId
    #[test]
    fn test_88() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2::outpost:op-01234567890123456:outpost:op1".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: missing account ID [outpost accesspoint ARN with missing accountId]");
        assert_eq!(format!("{}", error), "Invalid ARN: missing account ID")
    }

    /// bucket ARN with missing accountId
    #[test]
    fn test_89() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2::outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: missing account ID [bucket ARN with missing accountId]");
        assert_eq!(format!("{}", error), "Invalid ARN: missing account ID")
    }

    /// endpoint url with accesspoint (non-arn)
    #[test]
    fn test_90() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("apname".to_string())
            .endpoint("https://beta.example.com".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://123456789012.beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://123456789012.beta.example.com")
                .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 name with an accesspoint arn@us-west-2
    #[test]
    fn test_91() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .endpoint("https://beta.example.com".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://beta.example.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://beta.example.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// DualStack + Custom endpoint is not supported(non-arn)
    #[test]
    fn test_92() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("apname".to_string())
            .endpoint("https://beta.example.com".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid Configuration: DualStack and custom endpoint are not supported [DualStack + Custom endpoint is not supported(non-arn)]");
        assert_eq!(
            format!("{}", error),
            "Invalid Configuration: DualStack and custom endpoint are not supported"
        )
    }

    /// get bucket with custom endpoint and dualstack is not supported@us-west-2
    #[test]
    fn test_93() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .endpoint("https://s3-outposts.us-west-2.api.aws".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid Configuration: DualStack and custom endpoint are not supported [get bucket with custom endpoint and dualstack is not supported@us-west-2]");
        assert_eq!(
            format!("{}", error),
            "Invalid Configuration: DualStack and custom endpoint are not supported"
        )
    }

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

    /// ListRegionalBuckets + invalid OutpostId.
    #[test]
    fn test_95() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("012345678912".to_string())
            .outpost_id("?outpost/invalid+".to_string())
            .region("us-west-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error =
            endpoint.expect_err("expected error: OutpostId must only contain a-z, A-Z, 0-9 and `-`. [ListRegionalBuckets + invalid OutpostId.]");
        assert_eq!(format!("{}", error), "OutpostId must only contain a-z, A-Z, 0-9 and `-`.")
    }

    /// bucket ARN with mismatched accountId
    #[test]
    fn test_96() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:999999:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .account_id("012345678912".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid ARN: the accountId specified in the ARN (`999999`) does not match the parameter (`012345678912`) [bucket ARN with mismatched accountId]");
        assert_eq!(
            format!("{}", error),
            "Invalid ARN: the accountId specified in the ARN (`999999`) does not match the parameter (`012345678912`)"
        )
    }

    /// OutpostId with invalid region
    #[test]
    fn test_97() {
        let params = crate::config::endpoint::Params::builder()
            .outpost_id("op-123".to_string())
            .region("invalid-region 42".to_string())
            .account_id("0123456".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [OutpostId with invalid region]");
        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
    }

    /// OutpostId with RequireAccountId unset
    #[test]
    fn test_98() {
        let params = crate::config::endpoint::Params::builder()
            .outpost_id("op-123".to_string())
            .region("us-west-2".to_string())
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-west-2.amazonaws.com")
                .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()
        );
    }

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

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

    /// Accesspoint ARN with region mismatch and UseArnRegion unset
    #[test]
    fn test_101() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .account_id("123456789012".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

    /// Bucket ARN with region mismatch and UseArnRegion unset
    #[test]
    fn test_102() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-east-1.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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()
        );
    }

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

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

    /// Accesspoint ARN with region mismatch, UseArnRegion=false and custom endpoint
    #[test]
    fn test_105() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
            .region("us-west-2".to_string())
            .endpoint("https://example.com".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_arn_region(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 `cn-north-1` does not match client region `us-west-2` and UseArnRegion is `false` [Accesspoint ARN with region mismatch, UseArnRegion=false and custom endpoint]");
        assert_eq!(
            format!("{}", error),
            "Invalid configuration: region from ARN `cn-north-1` does not match client region `us-west-2` and UseArnRegion is `false`"
        )
    }

    /// outpost bucket arn@us-west-2
    #[test]
    fn test_106() {
        let params = crate::config::endpoint::Params::builder()
            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
            .region("us-west-2".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-outposts.us-west-2.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3-outposts.us-west-2.amazonaws.com")
                .header("x-amz-account-id", "123456789012")
                .header("x-amz-outpost-id", "op-01234567890123456")
                .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 Snow Control with bucket
    #[test]
    fn test_107() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .bucket("bucketName".to_string())
            .endpoint("https://10.0.1.12:433".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.1.12:433");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://10.0.1.12:433")
                .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 Control without bucket
    #[test]
    fn test_108() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .endpoint("https://10.0.1.12:433".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.1.12:433");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://10.0.1.12:433")
                .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 Control with bucket and without port
    #[test]
    fn test_109() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .bucket("bucketName".to_string())
            .endpoint("https://10.0.1.12".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.1.12");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://10.0.1.12")
                .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 Control with bucket and with DNS
    #[test]
    fn test_110() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .bucket("bucketName".to_string())
            .endpoint("http://s3snow.com".to_string())
            .use_fips(false)
            .use_dual_stack(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: http://s3snow.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("http://s3snow.com")
                .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 Control with FIPS enabled
    #[test]
    fn test_111() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .bucket("bucketName".to_string())
            .endpoint("https://10.0.1.12:433".to_string())
            .use_fips(true)
            .use_dual_stack(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: S3 Snow does not support FIPS [S3 Snow Control with FIPS enabled]");
        assert_eq!(format!("{}", error), "S3 Snow does not support FIPS")
    }

    /// S3 Snow Control with Dualstack enabled
    #[test]
    fn test_112() {
        let params = crate::config::endpoint::Params::builder()
            .region("snow".to_string())
            .bucket("bucketName".to_string())
            .endpoint("https://10.0.1.12:433".to_string())
            .use_fips(false)
            .use_dual_stack(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: S3 Snow does not support DualStack [S3 Snow Control with Dualstack enabled]");
        assert_eq!(format!("{}", error), "S3 Snow does not support DualStack")
    }

    /// Tagging on express bucket routed to s3express-control
    #[test]
    fn test_113() {
        let params = crate::config::endpoint::Params::builder()
            .resource_arn("arn:aws:s3express:us-east-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.us-east-1.amazonaws.com")
                .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())
                )
                .build()
        );
    }

    /// Tagging on express ap routed to s3express-control
    #[test]
    fn test_114() {
        let params = crate::config::endpoint::Params::builder()
            .resource_arn("arn:aws:s3express:us-east-1:871317572157:accesspoint/crachlintest--use1-az4--xa-s3".to_string())
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.us-east-1.amazonaws.com")
                .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())
                )
                .build()
        );
    }

    /// Tagging on express bucket routed to s3express-control FIPS when FIPS enabled
    #[test]
    fn test_115() {
        let params = crate::config::endpoint::Params::builder()
            .resource_arn("arn:aws:s3express:us-east-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control-fips.us-east-1.amazonaws.com")
                .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())
                )
                .build()
        );
    }

    /// Tagging on express bucket cn routed to s3express-control china endpoint
    #[test]
    fn test_116() {
        let params = crate::config::endpoint::Params::builder()
            .resource_arn("arn:aws-cn:s3express:cn-north-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
            .account_id("871317572157".to_string())
            .region("cn-north-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.cn-north-1.amazonaws.com.cn")
                .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())
                )
                .build()
        );
    }

    /// Tagging on express bucket cn routed to s3express-control china endpoint with FIPS
    #[test]
    fn test_117() {
        let params = crate::config::endpoint::Params::builder()
            .resource_arn("arn:aws-cn:s3express:cn-north-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
            .account_id("871317572157".to_string())
            .region("cn-north-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err(
            "expected error: Partition does not support FIPS [Tagging on express bucket cn routed to s3express-control china endpoint with FIPS]",
        );
        assert_eq!(format!("{}", error), "Partition does not support FIPS")
    }

    /// Tagging on express bucket with custom endpoint routed to custom endpoint
    #[test]
    fn test_118() {
        let params = crate::config::endpoint::Params::builder()
            .resource_arn("arn:aws:s3express:us-east-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
            .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.express-control.s3.aws.dev");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://my-endpoint.express-control.s3.aws.dev")
                .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())
                )
                .build()
        );
    }

    /// Tagging on express access point with custom endpoint routed to custom endpoint
    #[test]
    fn test_119() {
        let params = crate::config::endpoint::Params::builder()
            .resource_arn("arn:aws:s3express:us-east-1:871317572157:accesspoint/crachlintest--use1-az4--xa-s3".to_string())
            .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.express-control.s3.aws.dev");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://my-endpoint.express-control.s3.aws.dev")
                .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())
                )
                .build()
        );
    }

    /// Tagging on express bucket with dualstack and custom endpoint fails
    #[test]
    fn test_120() {
        let params = crate::config::endpoint::Params::builder()
            .resource_arn("arn:aws:s3express:us-east-1:871317572157:bucket/crachlintest--use1-az4--x-s3".to_string())
            .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid Configuration: DualStack and custom endpoint are not supported [Tagging on express bucket with dualstack and custom endpoint fails]");
        assert_eq!(
            format!("{}", error),
            "Invalid Configuration: DualStack and custom endpoint are not supported"
        )
    }

    /// Access Point APIs on express bucket routed to s3express-control
    #[test]
    fn test_121() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.us-east-1.amazonaws.com")
                .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())
                )
                .build()
        );
    }

    /// Access Point APIs on express bucket routed to s3express-control for List
    #[test]
    fn test_122() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .use_s3_express_control_endpoint(true)
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.us-east-1.amazonaws.com")
                .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())
                )
                .build()
        );
    }

    /// Access Point APIs on express bucket routed to s3express-control for FIPS
    #[test]
    fn test_123() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control-fips.us-east-1.amazonaws.com")
                .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())
                )
                .build()
        );
    }

    /// Access Point APIs on express bucket routed to s3express-control for FIPS for List
    #[test]
    fn test_124() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .use_s3_express_control_endpoint(true)
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control-fips.us-east-1.amazonaws.com")
                .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())
                )
                .build()
        );
    }

    /// Access Point APIs on express bucket routed to s3express-control for china region
    #[test]
    fn test_125() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
            .account_id("871317572157".to_string())
            .region("cn-north-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.cn-north-1.amazonaws.com.cn")
                .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())
                )
                .build()
        );
    }

    /// Access Point APIs on express bucket routed to s3express-control for china region for List
    #[test]
    fn test_126() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .region("cn-north-1".to_string())
            .use_s3_express_control_endpoint(true)
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.cn-north-1.amazonaws.com.cn");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://s3express-control.cn-north-1.amazonaws.com.cn")
                .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())
                )
                .build()
        );
    }

    /// Error when Access Point APIs on express bucket routed to s3express-control for china and FIPS
    #[test]
    fn test_127() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .region("cn-north-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(true)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Error when Access Point APIs on express bucket routed to s3express-control for china and FIPS]");
        assert_eq!(format!("{}", error), "Partition does not support FIPS")
    }

    /// Error Access Point APIs on express bucket routed to s3express-control invalid zone
    #[test]
    fn test_128() {
        let params = crate::config::endpoint::Params::builder()
            .access_point_name("myaccesspoint-garbage-zone--xa-s3".to_string())
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Unrecognized S3Express Access Point name format. [Error Access Point APIs on express bucket routed to s3express-control invalid zone]");
        assert_eq!(format!("{}", error), "Unrecognized S3Express Access Point name format.")
    }

    /// Access Point APIs on express bucket routed to custom endpoint if provided
    #[test]
    fn test_129() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
            .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.express-control.s3.aws.dev");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://my-endpoint.express-control.s3.aws.dev")
                .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())
                )
                .build()
        );
    }

    /// Access Point APIs on express bucket routed to custom endpoint if provided for List
    #[test]
    fn test_130() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .use_s3_express_control_endpoint(true)
            .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
            .requires_account_id(true)
            .use_dual_stack(false)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.express-control.s3.aws.dev");
        assert_eq!(
            endpoint,
            ::aws_smithy_types::endpoint::Endpoint::builder()
                .url("https://my-endpoint.express-control.s3.aws.dev")
                .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())
                )
                .build()
        );
    }

    /// Error on Access Point APIs on express bucket for dual stack
    #[test]
    fn test_131() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint
            .expect_err("expected error: S3Express does not support Dual-stack. [Error on Access Point APIs on express bucket for dual stack]");
        assert_eq!(format!("{}", error), "S3Express does not support Dual-stack.")
    }

    /// Error Access Point APIs on express bucket for dual stack for List
    #[test]
    fn test_132() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .use_s3_express_control_endpoint(true)
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint
            .expect_err("expected error: S3Express does not support Dual-stack. [Error Access Point APIs on express bucket for dual stack for List]");
        assert_eq!(format!("{}", error), "S3Express does not support Dual-stack.")
    }

    /// Error on Access Point APIs on express bucket for custom endpoint and dual stack
    #[test]
    fn test_133() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .access_point_name("myaccesspoint--abcd-ab1--xa-s3".to_string())
            .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
            .region("us-east-1".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid Configuration: DualStack and custom endpoint are not supported [Error on Access Point APIs on express bucket for custom endpoint and dual stack]");
        assert_eq!(
            format!("{}", error),
            "Invalid Configuration: DualStack and custom endpoint are not supported"
        )
    }

    /// Error Access Point APIs on express bucket for custom endpoint and dual stack for List
    #[test]
    fn test_134() {
        let params = crate::config::endpoint::Params::builder()
            .account_id("871317572157".to_string())
            .region("us-east-1".to_string())
            .use_s3_express_control_endpoint(true)
            .endpoint("https://my-endpoint.express-control.s3.aws.dev".to_string())
            .requires_account_id(true)
            .use_dual_stack(true)
            .use_fips(false)
            .build()
            .expect("invalid params");
        let resolver = crate::config::endpoint::DefaultResolver::new();
        let endpoint = resolver.resolve_endpoint(&params);
        let error = endpoint.expect_err("expected error: Invalid Configuration: DualStack and custom endpoint are not supported [Error Access Point APIs on express bucket for custom endpoint and dual stack for List]");
        assert_eq!(
            format!("{}", error),
            "Invalid Configuration: DualStack and custom endpoint are not supported"
        )
    }
}

/// Endpoint resolver trait specific to AWS S3 Control
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 region = &params.region;
        let use_fips = &params.use_fips;
        let use_dual_stack = &params.use_dual_stack;
        let endpoint = &params.endpoint;
        let account_id = &params.account_id;
        let requires_account_id = &params.requires_account_id;
        let outpost_id = &params.outpost_id;
        let bucket = &params.bucket;
        let access_point_name = &params.access_point_name;
        let use_arn_region = &params.use_arn_region;
        let resource_arn = &params.resource_arn;
        let use_s3_express_control_endpoint = &params.use_s3_express_control_endpoint;

        let mut current_ref: i32 = 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(
                            "Partition does not support FIPS".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        2 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "AccountId is required but not set".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        3 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "AccountId must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        4 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "OutpostId must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        5 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid Configuration: DualStack and custom endpoint are not supported".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        6 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        7 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dual_stack_dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        8 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        9 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dual_stack_dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        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.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        11 => ::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),
                        12 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let resource_arn_ctx_1 = context
                                .resource_arn_ctx_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid configuration: region from ARN `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&resource_arn_ctx_1.region());
                                out.push_str("` does not match client region `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&region.as_ref());
                                out.push_str("` and UseArnRegion is `false`");
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        13 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3Express does not support Dual-stack.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        14 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3express")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        15 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3express-control-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3express")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        16 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3express-control.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3express")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        17 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_3 = context
                                .arn_partition_ssa_3
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Client was configured for partition `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&partition_result.name());
                                out.push_str("` but ARN has `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&arn_partition_ssa_3.name());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        18 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Unrecognized S3Express Access Point name format.".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        19 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 Snow does not support DualStack".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        20 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "S3 Snow does not support FIPS".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        21 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        22 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let access_point_arn = context.access_point_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid configuration: region from ARN `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&access_point_arn.region());
                                out.push_str("` does not match client region `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&region.as_ref());
                                out.push_str("` and UseArnRegion is `false`");
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        23 => {
                            let account_id = params.account_id.as_deref().unwrap_or_default();
                            let access_point_arn = context.access_point_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: the accountId specified in the ARN (`");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&access_point_arn.account_id());
                                out.push_str("`) does not match the parameter (`");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&account_id.as_ref());
                                out.push_str("`)");
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        24 => {
                            let access_point_arn = context.access_point_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_1 = context
                                .arn_partition_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&arn_partition_ssa_1.dual_stack_dns_suffix());
                                        out
                                    })
                                    .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", access_point_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        25 => {
                            let access_point_arn = context.access_point_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_1 = context
                                .arn_partition_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&arn_partition_ssa_1.dns_suffix());
                                        out
                                    })
                                    .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", access_point_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        26 => {
                            let access_point_arn = context.access_point_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_1 = context
                                .arn_partition_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&arn_partition_ssa_1.dual_stack_dns_suffix());
                                        out
                                    })
                                    .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", access_point_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        27 => {
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let access_point_arn = context.access_point_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", access_point_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        28 => {
                            let access_point_arn = context.access_point_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_1 = context
                                .arn_partition_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&access_point_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&arn_partition_ssa_1.dns_suffix());
                                        out
                                    })
                                    .header("x-amz-account-id", access_point_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_1.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", access_point_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        29 => {
                            let outpost_type_ssa_1 = context
                                .outpost_type_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Expected an outpost type `accesspoint`, found `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&outpost_type_ssa_1.as_ref());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        30 => ::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),
                        31 => ::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),
                        32 => {
                            let access_point_arn = context.access_point_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&access_point_arn.account_id());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        33 => ::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),
                        34 => {
                            let access_point_arn = context.access_point_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid region in ARN: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&access_point_arn.region());
                                out.push_str("` (invalid DNS name)");
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        35 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_1 = context
                                .arn_partition_ssa_1
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Client was configured for partition `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&partition_result.name());
                                out.push_str("` but ARN has `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&arn_partition_ssa_1.name());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        36 => {
                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`., found: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&outpost_id_ssa_1.as_ref());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        37 => ::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),
                        38 => ::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),
                        39 => {
                            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)
                        }
                        40 => {
                            let account_id = params.account_id.as_deref().unwrap_or_default();
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: the accountId specified in the ARN (`");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&bucket_arn.account_id());
                                out.push_str("`) does not match the parameter (`");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&account_id.as_ref());
                                out.push_str("`)");
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        41 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_2 = context
                                .arn_partition_ssa_2
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&arn_partition_ssa_2.dual_stack_dns_suffix());
                                        out
                                    })
                                    .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        42 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_2 = context
                                .arn_partition_ssa_2
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&arn_partition_ssa_2.dns_suffix());
                                        out
                                    })
                                    .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        43 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_2 = context
                                .arn_partition_ssa_2
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&arn_partition_ssa_2.dual_stack_dns_suffix());
                                        out
                                    })
                                    .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        44 => {
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        45 => {
                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_2 = context
                                .arn_partition_ssa_2
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-outposts.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&bucket_arn.region());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&arn_partition_ssa_2.dns_suffix());
                                        out
                                    })
                                    .header("x-amz-account-id", bucket_arn.account_id().to_owned())
                                    .header("x-amz-outpost-id", outpost_id_ssa_2.to_owned())
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3-outposts")
                                            .put("signingRegion", bucket_arn.region()),
                                    )
                                    .build(),
                            )
                        }
                        46 => {
                            let outpost_type_ssa_2 = context
                                .outpost_type_ssa_2
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: Expected an outpost type `bucket`, found `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&outpost_type_ssa_2.as_ref());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        47 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Invalid ARN: expected a bucket name".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        48 => {
                            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)
                        }
                        49 => {
                            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)
                        }
                        50 => {
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            let arn_partition_ssa_2 = context
                                .arn_partition_ssa_2
                                .as_ref()
                                .expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Client was configured for partition `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&partition_result.name());
                                out.push_str("` but ARN has `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&arn_partition_ssa_2.name());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        51 => {
                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
                                let mut out = String::new();
                                out.push_str("Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`., found: `");
                                #[allow(clippy::needless_borrow)]
                                out.push_str(&outpost_id_ssa_2.as_ref());
                                out.push('`');
                                out
                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
                        }
                        52 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let account_id = params.account_id.as_deref().unwrap_or_default();
                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.scheme());
                                        out.push_str("://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&account_id.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.authority());
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&url.path());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        53 => {
                            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(),
                            )
                        }
                        54 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let account_id = params.account_id.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&account_id.as_ref());
                                        out.push_str(".s3-control-fips.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        55 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-control-fips.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        56 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let account_id = params.account_id.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&account_id.as_ref());
                                        out.push_str(".s3-control-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        57 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-control-fips.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        58 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let account_id = params.account_id.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&account_id.as_ref());
                                        out.push_str(".s3-control.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        59 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-control.dualstack.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        60 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let account_id = params.account_id.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&account_id.as_ref());
                                        out.push_str(".s3-control.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        61 => {
                            let region = params.region.as_deref().unwrap_or_default();
                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
                            ::std::result::Result::Ok(
                                ::aws_smithy_types::endpoint::Endpoint::builder()
                                    .url({
                                        let mut out = String::new();
                                        out.push_str("https://s3-control.");
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&region.as_ref());
                                        out.push('.');
                                        #[allow(clippy::needless_borrow)]
                                        out.push_str(&partition_result.dns_suffix());
                                        out
                                    })
                                    .auth_scheme(
                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
                                            .put("disableDoubleEncoding", true)
                                            .put("signingName", "s3")
                                            .put("signingRegion", region.as_ref()),
                                    )
                                    .build(),
                            )
                        }
                        62 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "Region must be set".to_string(),
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                        _ => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
                            "No endpoint rule matched",
                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
                    };
                }
                1 | -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 => (|_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),
                        2 => (use_fips) == (&true),
                        3 => (|_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),
                        4 => outpost_id.is_some(),
                        5 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(param) = outpost_id { param } else { return false },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        6 => resource_arn.is_some(),
                        7 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let resource_arn_ctx_1 = &mut context.resource_arn_ctx_1;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *resource_arn_ctx_1 = crate::endpoint_lib::arn::parse_arn(
                                    if let Some(param) = resource_arn { param } else { return false },
                                    _diagnostic_collector,
                                )
                                .map(|inner| inner.into());
                                resource_arn_ctx_1.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        8 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let resource_arn_ctx_1 = &context.resource_arn_ctx_1;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = resource_arn_ctx_1 {
                                inner.service()
                            } else {
                                return false;
                            }) == ("s3express")
                        })(&mut _diagnostic_collector),
                        9 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let resource_arn_ctx_1 = &context.resource_arn_ctx_1;
                            let arn_partition_ssa_3 = &mut context.arn_partition_ssa_3;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *arn_partition_ssa_3 = partition_resolver
                                    .resolve_partition(
                                        if let Some(inner) = resource_arn_ctx_1 {
                                            inner.region()
                                        } else {
                                            return false;
                                        },
                                        _diagnostic_collector,
                                    )
                                    .map(|inner| inner.into());
                                arn_partition_ssa_3.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        10 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_result = &context.partition_result;
                            let arn_partition_ssa_3 = &context.arn_partition_ssa_3;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = arn_partition_ssa_3 {
                                inner.name()
                            } else {
                                return false;
                            }) == (if let Some(inner) = partition_result {
                                inner.name()
                            } else {
                                return false;
                            })
                        })(&mut _diagnostic_collector),
                        11 => endpoint.is_some(),
                        12 => (use_dual_stack) == (&true),
                        13 => (|_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),
                        14 => (|_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),
                        15 => access_point_name.is_some(),
                        16 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = access_point_name { param } else { return false },
                                    0,
                                    7,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--xa-s3")
                        })(&mut _diagnostic_collector),
                        17 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::substring::substring(
                                if let Some(param) = access_point_name { param } else { return false },
                                7,
                                15,
                                true,
                                _diagnostic_collector,
                            ))
                            .is_some()
                        })(&mut _diagnostic_collector),
                        18 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = access_point_name { param } else { return false },
                                    15,
                                    17,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        19 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::substring::substring(
                                if let Some(param) = access_point_name { param } else { return false },
                                7,
                                16,
                                true,
                                _diagnostic_collector,
                            ))
                            .is_some()
                        })(&mut _diagnostic_collector),
                        20 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (region) == &mut Some(("snow".to_string().into()))
                        })(&mut _diagnostic_collector),
                        21 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &mut context.access_point_arn;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *access_point_arn = crate::endpoint_lib::arn::parse_arn(
                                    if let Some(param) = access_point_name { param } else { return false },
                                    _diagnostic_collector,
                                )
                                .map(|inner| inner.into());
                                access_point_arn.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        22 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let arn_type_ssa_1 = &mut context.arn_type_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *arn_type_ssa_1 = if let Some(inner) = access_point_arn {
                                    inner.resource_id().first().cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                arn_type_ssa_1.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        23 => bucket.is_some(),
                        24 => (|_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),
                        25 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let arn_type_ssa_2 = &mut context.arn_type_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *arn_type_ssa_2 = if let Some(inner) = bucket_arn {
                                    inner.resource_id().first().cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                arn_type_ssa_2.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        26 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let arn_type_ssa_2 = &context.arn_type_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            (arn_type_ssa_2) == &mut Some(("".to_string().into()))
                        })(&mut _diagnostic_collector),
                        27 => (|_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),
                        28 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *outpost_id_ssa_2 = if let Some(inner) = bucket_arn {
                                    inner.resource_id().get(1).cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                outpost_id_ssa_2.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        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) = access_point_name { 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 arn_type_ssa_1 = &context.arn_type_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            (arn_type_ssa_1) == &mut Some(("".to_string().into()))
                        })(&mut _diagnostic_collector),
                        31 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = access_point_arn {
                                inner.service()
                            } else {
                                return false;
                            }) == ("s3-outposts")
                        })(&mut _diagnostic_collector),
                        32 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *outpost_id_ssa_1 = if let Some(inner) = access_point_arn {
                                    inner.resource_id().get(1).cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                outpost_id_ssa_1.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        33 => account_id.is_some(),
                        34 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(param) = account_id { param } else { return false },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        35 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(requires_account_id.clone(), false)) == (true)
                        })(&mut _diagnostic_collector),
                        36 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let partition_resolver = &self.partition_resolver;
                            (account_id)
                                == &mut Some(
                                    (if let Some(inner) = access_point_arn {
                                        inner.account_id()
                                    } else {
                                        return false;
                                    }
                                    .into()),
                                )
                        })(&mut _diagnostic_collector),
                        37 => (|_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),
                        38 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            (account_id)
                                == &mut Some(
                                    (if let Some(inner) = bucket_arn {
                                        inner.account_id()
                                    } else {
                                        return false;
                                    }
                                    .into()),
                                )
                        })(&mut _diagnostic_collector),
                        39 => (|_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),
                        40 => (|_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),
                        41 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let partition_resolver = &self.partition_resolver;
                            (region)
                                == &mut Some(
                                    (if let Some(inner) = access_point_arn {
                                        inner.region()
                                    } else {
                                        return false;
                                    }
                                    .into()),
                                )
                        })(&mut _diagnostic_collector),
                        42 => (|_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),
                        43 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let arn_partition_ssa_2 = &mut context.arn_partition_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *arn_partition_ssa_2 = partition_resolver
                                    .resolve_partition(
                                        if let Some(inner) = bucket_arn { inner.region() } else { return false },
                                        _diagnostic_collector,
                                    )
                                    .map(|inner| inner.into());
                                arn_partition_ssa_2.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        44 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_result = &context.partition_result;
                            let arn_partition_ssa_2 = &context.arn_partition_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = arn_partition_ssa_2 {
                                inner.name()
                            } else {
                                return false;
                            }) == (if let Some(inner) = partition_result {
                                inner.name()
                            } else {
                                return false;
                            })
                        })(&mut _diagnostic_collector),
                        45 => (|_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),
                        46 => (|_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),
                        47 => (|_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),
                        48 => (|_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),
                        49 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let arn_partition_ssa_1 = &mut context.arn_partition_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *arn_partition_ssa_1 = partition_resolver
                                    .resolve_partition(
                                        if let Some(inner) = access_point_arn {
                                            inner.region()
                                        } else {
                                            return false;
                                        },
                                        _diagnostic_collector,
                                    )
                                    .map(|inner| inner.into());
                                arn_partition_ssa_1.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        50 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_result = &context.partition_result;
                            let arn_partition_ssa_1 = &context.arn_partition_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = arn_partition_ssa_1 {
                                inner.name()
                            } else {
                                return false;
                            }) == (if let Some(inner) = partition_result {
                                inner.name()
                            } else {
                                return false;
                            })
                        })(&mut _diagnostic_collector),
                        51 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(inner) = access_point_arn {
                                    inner.region()
                                } else {
                                    return false;
                                },
                                true,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        52 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let partition_resolver = &self.partition_resolver;
                            (if let Some(inner) = access_point_arn {
                                inner.account_id()
                            } else {
                                return false;
                            }) == ("")
                        })(&mut _diagnostic_collector),
                        53 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let partition_resolver = &self.partition_resolver;
                            crate::endpoint_lib::host::is_valid_host_label(
                                if let Some(inner) = access_point_arn {
                                    inner.account_id()
                                } else {
                                    return false;
                                },
                                false,
                                _diagnostic_collector,
                            )
                        })(&mut _diagnostic_collector),
                        54 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::substring::substring(
                                if let Some(param) = access_point_name { param } else { return false },
                                7,
                                20,
                                true,
                                _diagnostic_collector,
                            ))
                            .is_some()
                        })(&mut _diagnostic_collector),
                        55 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = access_point_name { param } else { return false },
                                    20,
                                    22,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        56 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::substring::substring(
                                if let Some(param) = access_point_name { param } else { return false },
                                7,
                                21,
                                true,
                                _diagnostic_collector,
                            ))
                            .is_some()
                        })(&mut _diagnostic_collector),
                        57 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = access_point_name { param } else { return false },
                                    21,
                                    23,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        58 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let outpost_type_ssa_1 = &mut context.outpost_type_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *outpost_type_ssa_1 = if let Some(inner) = access_point_arn {
                                    inner.resource_id().get(2).cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                outpost_type_ssa_1.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        59 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let access_point_arn = &context.access_point_arn;
                            let partition_resolver = &self.partition_resolver;
                            if let Some(inner) = access_point_arn {
                                inner.resource_id().get(3).cloned()
                            } else {
                                return false;
                            }
                            .is_some()
                        })(&mut _diagnostic_collector),
                        60 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let outpost_type_ssa_1 = &context.outpost_type_ssa_1;
                            let partition_resolver = &self.partition_resolver;
                            (outpost_type_ssa_1) == &mut Some(("accesspoint".to_string().into()))
                        })(&mut _diagnostic_collector),
                        61 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::substring::substring(
                                if let Some(param) = access_point_name { param } else { return false },
                                7,
                                27,
                                true,
                                _diagnostic_collector,
                            ))
                            .is_some()
                        })(&mut _diagnostic_collector),
                        62 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let partition_resolver = &self.partition_resolver;
                            (crate::endpoint_lib::coalesce::coalesce!(
                                if let Some(inner) = crate::endpoint_lib::substring::substring(
                                    if let Some(param) = access_point_name { param } else { return false },
                                    27,
                                    29,
                                    true,
                                    _diagnostic_collector
                                ) {
                                    inner
                                } else {
                                    return false;
                                },
                                "".to_string()
                            )) == ("--")
                        })(&mut _diagnostic_collector),
                        63 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let outpost_type_ssa_2 = &mut context.outpost_type_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            {
                                *outpost_type_ssa_2 = if let Some(inner) = bucket_arn {
                                    inner.resource_id().get(2).cloned()
                                } else {
                                    return false;
                                }
                                .map(|inner| inner.into());
                                outpost_type_ssa_2.is_some()
                            }
                        })(&mut _diagnostic_collector),
                        64 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let bucket_arn = &context.bucket_arn;
                            let partition_resolver = &self.partition_resolver;
                            if let Some(inner) = bucket_arn {
                                inner.resource_id().get(3).cloned()
                            } else {
                                return false;
                            }
                            .is_some()
                        })(&mut _diagnostic_collector),
                        65 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let outpost_type_ssa_2 = &context.outpost_type_ssa_2;
                            let partition_resolver = &self.partition_resolver;
                            (outpost_type_ssa_2) == &mut Some(("bucket".to_string().into()))
                        })(&mut _diagnostic_collector),
                        66 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
                            let resource_arn_ctx_1 = &context.resource_arn_ctx_1;
                            let partition_resolver = &self.partition_resolver;
                            (region)
                                == &mut Some(
                                    (if let Some(inner) = resource_arn_ctx_1 {
                                        inner.region()
                                    } else {
                                        return false;
                                    }
                                    .into()),
                                )
                        })(&mut _diagnostic_collector),
                        _ => unreachable!("Invalid condition index"),
                    };
                    current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };
                }
            }
        }
    }
}

impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
        // Check single-entry cache (lock-free read via ArcSwap)
        let cached = self.endpoint_cache.load();
        if let Some((cached_params, cached_endpoint)) = cached.as_ref() {
            if cached_params == params {
                return ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(::std::result::Result::Ok(cached_endpoint.clone()));
            }
        }
        drop(cached);
        let result = self.resolve_endpoint(params);
        if let ::std::result::Result::Ok(ref endpoint) = result {
            self.endpoint_cache.store(::std::sync::Arc::new(Some((params.clone(), endpoint.clone()))));
        }
        ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(result)
    }
}
const NODES: [crate::endpoint_lib::bdd_interpreter::BddNode; 428] = [
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: -1,
        high_ref: 1,
        low_ref: -1,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 0,
        high_ref: 3,
        low_ref: 100000062,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 1,
        high_ref: 27,
        low_ref: 4,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 5,
        low_ref: 6,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 23,
        low_ref: 6,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 7,
        low_ref: 8,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 17,
        low_ref: 8,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 9,
        low_ref: 100000062,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 10,
        low_ref: 100000062,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 11,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000038,
        low_ref: 12,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 13,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 14,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 100000051,
        low_ref: 15,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 16,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 100000051,
        low_ref: 100000039,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 18,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 100000038,
        low_ref: 19,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 31,
        high_ref: 20,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 32,
        high_ref: 21,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 100000036,
        low_ref: 22,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 100000036,
        low_ref: 334,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 24,
        low_ref: 25,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 388,
        low_ref: 25,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 26,
        low_ref: 100000062,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 383,
        low_ref: 100000062,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 2,
        high_ref: 214,
        low_ref: 28,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 4,
        high_ref: 201,
        low_ref: 29,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 6,
        high_ref: 30,
        low_ref: 33,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 7,
        high_ref: 31,
        low_ref: 33,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 32,
        low_ref: 33,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 9,
        high_ref: 194,
        low_ref: 33,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 77,
        low_ref: 34,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 36,
        low_ref: 35,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 169,
        low_ref: 80,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 100000013,
        low_ref: 37,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 38,
        low_ref: 40,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 100000013,
        low_ref: 39,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 60,
        low_ref: 40,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 41,
        low_ref: 188,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 42,
        low_ref: 188,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 43,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000038,
        low_ref: 44,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 45,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 46,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 47,
        low_ref: 48,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 48,
        low_ref: 297,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 51,
        low_ref: 49,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 50,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 52,
        low_ref: 100000039,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 52,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 43,
        high_ref: 53,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 44,
        high_ref: 54,
        low_ref: 100000050,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 45,
        high_ref: 55,
        low_ref: 100000049,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000033,
        low_ref: 56,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 47,
        high_ref: 57,
        low_ref: 100000048,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 58,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 59,
        low_ref: 100000047,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 65,
        high_ref: 100000043,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 61,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 100000038,
        low_ref: 62,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 31,
        high_ref: 63,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 32,
        high_ref: 64,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 65,
        low_ref: 66,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 66,
        low_ref: 324,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 68,
        low_ref: 67,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 68,
        low_ref: 334,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 69,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 70,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 71,
        low_ref: 100000035,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 72,
        low_ref: 100000034,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 100000033,
        low_ref: 73,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 53,
        high_ref: 74,
        low_ref: 100000032,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 58,
        high_ref: 75,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 59,
        high_ref: 76,
        low_ref: 100000030,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 100000026,
        low_ref: 100000029,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 181,
        low_ref: 78,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 168,
        low_ref: 79,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 126,
        low_ref: 80,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 81,
        low_ref: 83,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 171,
        low_ref: 82,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 109,
        low_ref: 83,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 84,
        low_ref: 85,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 91,
        low_ref: 85,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 87,
        low_ref: 86,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 379,
        low_ref: 89,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 88,
        low_ref: 381,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 90,
        low_ref: 89,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000061,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000060,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 92,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000038,
        low_ref: 93,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 94,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 95,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 96,
        low_ref: 97,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 97,
        low_ref: 297,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 100,
        low_ref: 98,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 99,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 101,
        low_ref: 100000039,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 101,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 43,
        high_ref: 102,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 44,
        high_ref: 103,
        low_ref: 100000050,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 45,
        high_ref: 104,
        low_ref: 100000049,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000033,
        low_ref: 105,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 47,
        high_ref: 106,
        low_ref: 100000048,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 107,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 108,
        low_ref: 100000047,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 65,
        high_ref: 100000045,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 110,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 100000038,
        low_ref: 111,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 31,
        high_ref: 112,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 32,
        high_ref: 113,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 114,
        low_ref: 115,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 115,
        low_ref: 324,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 117,
        low_ref: 116,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 117,
        low_ref: 334,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 118,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 119,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 120,
        low_ref: 100000035,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 121,
        low_ref: 100000034,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 100000033,
        low_ref: 122,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 53,
        high_ref: 123,
        low_ref: 100000032,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 58,
        high_ref: 124,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 59,
        high_ref: 125,
        low_ref: 100000030,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 100000028,
        low_ref: 100000029,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 128,
        low_ref: 127,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 100000021,
        low_ref: 131,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 100000014,
        low_ref: 129,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 100000021,
        low_ref: 130,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 151,
        low_ref: 131,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 132,
        low_ref: 285,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 133,
        low_ref: 285,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 134,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000038,
        low_ref: 135,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 136,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 137,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 138,
        low_ref: 139,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 139,
        low_ref: 297,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 142,
        low_ref: 140,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 141,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 143,
        low_ref: 100000039,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 143,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 43,
        high_ref: 144,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 44,
        high_ref: 145,
        low_ref: 100000050,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 45,
        high_ref: 146,
        low_ref: 100000049,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000033,
        low_ref: 147,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 47,
        high_ref: 148,
        low_ref: 100000048,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 149,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 150,
        low_ref: 100000047,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 65,
        high_ref: 100000044,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 152,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 100000038,
        low_ref: 153,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 31,
        high_ref: 154,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 32,
        high_ref: 155,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 156,
        low_ref: 157,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 157,
        low_ref: 324,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 159,
        low_ref: 158,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 159,
        low_ref: 334,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 160,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 161,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 162,
        low_ref: 100000035,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 163,
        low_ref: 100000034,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 100000033,
        low_ref: 164,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 53,
        high_ref: 165,
        low_ref: 100000032,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 58,
        high_ref: 166,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 59,
        high_ref: 167,
        low_ref: 100000030,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 100000027,
        low_ref: 100000029,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 100000014,
        low_ref: 169,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 170,
        low_ref: 100000016,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 171,
        low_ref: 100000016,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 17,
        high_ref: 172,
        low_ref: 173,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 100000016,
        low_ref: 173,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 174,
        low_ref: 175,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 29,
        high_ref: 100000016,
        low_ref: 175,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 54,
        high_ref: 176,
        low_ref: 177,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 55,
        high_ref: 100000016,
        low_ref: 177,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 56,
        high_ref: 178,
        low_ref: 179,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 57,
        high_ref: 100000016,
        low_ref: 179,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 61,
        high_ref: 180,
        low_ref: 100000018,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000016,
        low_ref: 100000018,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 100000005,
        low_ref: 182,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 370,
        low_ref: 183,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 184,
        low_ref: 186,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 100000005,
        low_ref: 185,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 388,
        low_ref: 186,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 187,
        low_ref: 188,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 383,
        low_ref: 188,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 190,
        low_ref: 189,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 379,
        low_ref: 192,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 191,
        low_ref: 381,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 193,
        low_ref: 192,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000059,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000058,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 10,
        high_ref: 195,
        low_ref: 100000017,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 197,
        low_ref: 196,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 396,
        low_ref: 199,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 404,
        low_ref: 198,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 402,
        low_ref: 199,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 100000016,
        low_ref: 200,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 100000016,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 5,
        high_ref: 202,
        low_ref: 407,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 208,
        low_ref: 203,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 204,
        low_ref: 210,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 206,
        low_ref: 205,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 100000002,
        low_ref: 207,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 207,
        low_ref: 100000003,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000009,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 426,
        low_ref: 209,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 422,
        low_ref: 210,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 212,
        low_ref: 211,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 100000002,
        low_ref: 213,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 213,
        low_ref: 100000003,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000010,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 3,
        high_ref: 100000001,
        low_ref: 215,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 4,
        high_ref: 406,
        low_ref: 216,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 6,
        high_ref: 217,
        low_ref: 220,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 7,
        high_ref: 218,
        low_ref: 220,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 8,
        high_ref: 219,
        low_ref: 220,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 9,
        high_ref: 393,
        low_ref: 220,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 264,
        low_ref: 221,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 223,
        low_ref: 222,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 345,
        low_ref: 267,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 100000013,
        low_ref: 224,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 225,
        low_ref: 227,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 100000013,
        low_ref: 226,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 247,
        low_ref: 227,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 228,
        low_ref: 364,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 229,
        low_ref: 364,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 230,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000038,
        low_ref: 231,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 232,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 233,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 234,
        low_ref: 235,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 235,
        low_ref: 297,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 238,
        low_ref: 236,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 237,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 239,
        low_ref: 100000039,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 239,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 43,
        high_ref: 240,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 44,
        high_ref: 241,
        low_ref: 100000050,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 45,
        high_ref: 242,
        low_ref: 100000049,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000033,
        low_ref: 243,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 47,
        high_ref: 244,
        low_ref: 100000048,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 245,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 246,
        low_ref: 100000047,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 65,
        high_ref: 100000041,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 248,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 100000038,
        low_ref: 249,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 31,
        high_ref: 250,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 32,
        high_ref: 251,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 252,
        low_ref: 253,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 253,
        low_ref: 324,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 255,
        low_ref: 254,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 255,
        low_ref: 334,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 256,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 257,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 258,
        low_ref: 100000035,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 259,
        low_ref: 100000034,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 100000033,
        low_ref: 260,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 53,
        high_ref: 261,
        low_ref: 100000032,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 58,
        high_ref: 262,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 59,
        high_ref: 263,
        low_ref: 100000030,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 100000024,
        low_ref: 100000029,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 357,
        low_ref: 265,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 344,
        low_ref: 266,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 278,
        low_ref: 267,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 268,
        low_ref: 270,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 347,
        low_ref: 269,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 318,
        low_ref: 270,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 271,
        low_ref: 272,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 291,
        low_ref: 272,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 274,
        low_ref: 273,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 379,
        low_ref: 276,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 275,
        low_ref: 381,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 277,
        low_ref: 276,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000057,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000056,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 280,
        low_ref: 279,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 100000020,
        low_ref: 283,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 100000014,
        low_ref: 281,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 100000020,
        low_ref: 282,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 318,
        low_ref: 283,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 284,
        low_ref: 285,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 291,
        low_ref: 285,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 287,
        low_ref: 286,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 379,
        low_ref: 289,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 288,
        low_ref: 381,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 290,
        low_ref: 289,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000053,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000052,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 292,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000038,
        low_ref: 293,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 294,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 295,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 296,
        low_ref: 306,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 38,
        high_ref: 306,
        low_ref: 297,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 300,
        low_ref: 298,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 299,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 301,
        low_ref: 100000039,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 301,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 43,
        high_ref: 302,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 44,
        high_ref: 303,
        low_ref: 100000050,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 45,
        high_ref: 304,
        low_ref: 100000049,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000033,
        low_ref: 305,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 47,
        high_ref: 100000040,
        low_ref: 100000048,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 309,
        low_ref: 307,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 308,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 42,
        high_ref: 310,
        low_ref: 100000039,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 310,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 43,
        high_ref: 311,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 44,
        high_ref: 312,
        low_ref: 100000050,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 45,
        high_ref: 313,
        low_ref: 100000049,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 46,
        high_ref: 100000033,
        low_ref: 314,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 47,
        high_ref: 315,
        low_ref: 100000048,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 63,
        high_ref: 316,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 64,
        high_ref: 317,
        low_ref: 100000047,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 65,
        high_ref: 100000042,
        low_ref: 100000046,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 319,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 100000038,
        low_ref: 320,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 31,
        high_ref: 321,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 32,
        high_ref: 322,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 323,
        low_ref: 332,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 36,
        high_ref: 332,
        low_ref: 324,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 326,
        low_ref: 325,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 326,
        low_ref: 334,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 327,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 328,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 329,
        low_ref: 100000035,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 330,
        low_ref: 100000034,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 100000033,
        low_ref: 331,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 53,
        high_ref: 100000023,
        low_ref: 100000032,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 335,
        low_ref: 333,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 41,
        high_ref: 335,
        low_ref: 334,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000022,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 336,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 49,
        high_ref: 337,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 50,
        high_ref: 338,
        low_ref: 100000035,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 51,
        high_ref: 339,
        low_ref: 100000034,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 52,
        high_ref: 100000033,
        low_ref: 340,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 53,
        high_ref: 341,
        low_ref: 100000032,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 58,
        high_ref: 342,
        low_ref: 100000031,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 59,
        high_ref: 343,
        low_ref: 100000030,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 60,
        high_ref: 100000025,
        low_ref: 100000029,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 100000014,
        low_ref: 345,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 346,
        low_ref: 100000015,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 347,
        low_ref: 100000015,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 17,
        high_ref: 348,
        low_ref: 349,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 18,
        high_ref: 100000015,
        low_ref: 349,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 19,
        high_ref: 350,
        low_ref: 351,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 29,
        high_ref: 100000015,
        low_ref: 351,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 54,
        high_ref: 352,
        low_ref: 353,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 55,
        high_ref: 100000015,
        low_ref: 353,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 56,
        high_ref: 354,
        low_ref: 355,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 57,
        high_ref: 100000015,
        low_ref: 355,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 61,
        high_ref: 356,
        low_ref: 100000018,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 62,
        high_ref: 100000015,
        low_ref: 100000018,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 13,
        high_ref: 100000005,
        low_ref: 358,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 370,
        low_ref: 359,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 360,
        low_ref: 362,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 100000005,
        low_ref: 361,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 388,
        low_ref: 362,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 363,
        low_ref: 364,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 383,
        low_ref: 364,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 366,
        low_ref: 365,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 379,
        low_ref: 368,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 367,
        low_ref: 381,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 369,
        low_ref: 368,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000055,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000054,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 15,
        high_ref: 372,
        low_ref: 371,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 100000019,
        low_ref: 375,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 16,
        high_ref: 100000005,
        low_ref: 373,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 20,
        high_ref: 100000019,
        low_ref: 374,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 21,
        high_ref: 388,
        low_ref: 375,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 23,
        high_ref: 376,
        low_ref: 377,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 24,
        high_ref: 383,
        low_ref: 377,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 380,
        low_ref: 378,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 379,
        low_ref: 382,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000002,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 382,
        low_ref: 381,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000003,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000005,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 25,
        high_ref: 384,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 26,
        high_ref: 100000038,
        low_ref: 385,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 27,
        high_ref: 386,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 28,
        high_ref: 387,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 40,
        high_ref: 100000005,
        low_ref: 100000051,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 22,
        high_ref: 389,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 30,
        high_ref: 100000038,
        low_ref: 390,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 31,
        high_ref: 391,
        low_ref: 100000038,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 32,
        high_ref: 392,
        low_ref: 100000037,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 48,
        high_ref: 100000005,
        low_ref: 100000036,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 10,
        high_ref: 394,
        low_ref: 100000017,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 398,
        low_ref: 395,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 396,
        low_ref: 400,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 100000013,
        low_ref: 397,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 100000013,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 404,
        low_ref: 399,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 402,
        low_ref: 400,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 100000015,
        low_ref: 401,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 100000015,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 100000014,
        low_ref: 403,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 100000014,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 39,
        high_ref: 100000005,
        low_ref: 405,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 66,
        high_ref: 100000005,
        low_ref: 100000012,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 5,
        high_ref: 410,
        low_ref: 407,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 409,
        low_ref: 408,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 100000002,
        low_ref: 100000004,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 100000004,
        low_ref: 100000003,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 11,
        high_ref: 416,
        low_ref: 411,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 412,
        low_ref: 418,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 414,
        low_ref: 413,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 100000002,
        low_ref: 415,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 415,
        low_ref: 100000003,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000007,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 12,
        high_ref: 426,
        low_ref: 417,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 14,
        high_ref: 422,
        low_ref: 418,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 420,
        low_ref: 419,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 100000002,
        low_ref: 421,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 421,
        low_ref: 100000003,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000008,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 424,
        low_ref: 423,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 100000002,
        low_ref: 425,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 425,
        low_ref: 100000003,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 37,
        high_ref: 100000006,
        low_ref: 100000011,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 33,
        high_ref: 428,
        low_ref: 427,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 35,
        high_ref: 100000002,
        low_ref: 100000005,
    },
    crate::endpoint_lib::bdd_interpreter::BddNode {
        condition_index: 34,
        high_ref: 100000005,
        low_ref: 100000003,
    },
];
// These are all optional since they are set by conditions and will
// all be unset when we start evaluation
#[derive(Default)]
#[allow(unused_lifetimes)]
pub(crate) struct ConditionContext<'a> {
    pub(crate) partition_result: Option<crate::endpoint_lib::partition::Partition<'a>>,
    pub(crate) resource_arn_ctx_1: Option<crate::endpoint_lib::arn::Arn<'a>>,
    pub(crate) arn_partition_ssa_3: Option<crate::endpoint_lib::partition::Partition<'a>>,
    pub(crate) url: Option<crate::endpoint_lib::parse_url::Url<'a>>,
    pub(crate) access_point_arn: Option<crate::endpoint_lib::arn::Arn<'a>>,
    pub(crate) arn_type_ssa_1: ::std::option::Option<::std::string::String>,
    pub(crate) bucket_arn: Option<crate::endpoint_lib::arn::Arn<'a>>,
    pub(crate) arn_type_ssa_2: ::std::option::Option<::std::string::String>,
    pub(crate) outpost_id_ssa_2: ::std::option::Option<::std::string::String>,
    pub(crate) outpost_id_ssa_1: ::std::option::Option<::std::string::String>,
    pub(crate) arn_partition_ssa_2: Option<crate::endpoint_lib::partition::Partition<'a>>,
    pub(crate) arn_partition_ssa_1: Option<crate::endpoint_lib::partition::Partition<'a>>,
    pub(crate) outpost_type_ssa_1: ::std::option::Option<::std::string::String>,
    pub(crate) outpost_type_ssa_2: ::std::option::Option<::std::string::String>,
    // Sometimes none of the members reference the lifetime, this makes it still valid
    phantom: std::marker::PhantomData<&'a ()>,
}

#[non_exhaustive]
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
/// Configuration parameters for resolving the correct endpoint
pub struct Params {
    /// The AWS region used to dispatch the request.
    pub(crate) region: ::std::option::Option<::std::string::String>,
    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
    pub(crate) use_fips: bool,
    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
    pub(crate) use_dual_stack: bool,
    /// Override the endpoint used to send this request
    pub(crate) endpoint: ::std::option::Option<::std::string::String>,
    /// The Account ID used to send the request. This is an optional parameter that will be set automatically for operations that require it.
    pub(crate) account_id: ::std::option::Option<::std::string::String>,
    /// Internal parameter for operations that require account id host prefix.
    pub(crate) requires_account_id: ::std::option::Option<bool>,
    /// The Outpost ID.  Some operations have an optional OutpostId which should be used in endpoint construction.
    pub(crate) outpost_id: ::std::option::Option<::std::string::String>,
    /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
    pub(crate) bucket: ::std::option::Option<::std::string::String>,
    /// The S3 AccessPointName used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 AccessPoint.
    pub(crate) access_point_name: ::std::option::Option<::std::string::String>,
    /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
    pub(crate) use_arn_region: ::std::option::Option<bool>,
    /// The resource ARN included in the request.  Only set on TagResource, UntagResourceand ListTagsForResource
    pub(crate) resource_arn: ::std::option::Option<::std::string::String>,
    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. ListDirectoryAccessPoints)
    pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
}
impl Params {
    /// Create a builder for [`Params`]
    pub fn builder() -> crate::config::endpoint::ParamsBuilder {
        crate::config::endpoint::ParamsBuilder::default()
    }
    /// The AWS region used to dispatch the request.
    pub fn region(&self) -> ::std::option::Option<&str> {
        self.region.as_deref()
    }
    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
    pub fn use_fips(&self) -> ::std::option::Option<bool> {
        Some(self.use_fips)
    }
    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
    pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
        Some(self.use_dual_stack)
    }
    /// Override the endpoint used to send this request
    pub fn endpoint(&self) -> ::std::option::Option<&str> {
        self.endpoint.as_deref()
    }
    /// The Account ID used to send the request. This is an optional parameter that will be set automatically for operations that require it.
    pub fn account_id(&self) -> ::std::option::Option<&str> {
        self.account_id.as_deref()
    }
    /// Internal parameter for operations that require account id host prefix.
    pub fn requires_account_id(&self) -> ::std::option::Option<bool> {
        self.requires_account_id
    }
    /// The Outpost ID.  Some operations have an optional OutpostId which should be used in endpoint construction.
    pub fn outpost_id(&self) -> ::std::option::Option<&str> {
        self.outpost_id.as_deref()
    }
    /// 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 S3 AccessPointName used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 AccessPoint.
    pub fn access_point_name(&self) -> ::std::option::Option<&str> {
        self.access_point_name.as_deref()
    }
    /// 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
    }
    /// The resource ARN included in the request.  Only set on TagResource, UntagResourceand ListTagsForResource
    pub fn resource_arn(&self) -> ::std::option::Option<&str> {
        self.resource_arn.as_deref()
    }
    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. ListDirectoryAccessPoints)
    pub fn use_s3_express_control_endpoint(&self) -> ::std::option::Option<bool> {
        self.use_s3_express_control_endpoint
    }
}

/// Builder for [`Params`]
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
pub struct ParamsBuilder {
    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>,
    account_id: ::std::option::Option<::std::string::String>,
    requires_account_id: ::std::option::Option<bool>,
    outpost_id: ::std::option::Option<::std::string::String>,
    bucket: ::std::option::Option<::std::string::String>,
    access_point_name: ::std::option::Option<::std::string::String>,
    use_arn_region: ::std::option::Option<bool>,
    resource_arn: ::std::option::Option<::std::string::String>,
    use_s3_express_control_endpoint: ::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 {
                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,
                account_id: self.account_id,
                requires_account_id: self.requires_account_id,
                outpost_id: self.outpost_id,
                bucket: self.bucket,
                access_point_name: self.access_point_name,
                use_arn_region: self.use_arn_region,
                resource_arn: self.resource_arn,
                use_s3_express_control_endpoint: self.use_s3_express_control_endpoint,
            },
        )
    }
    /// 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 account_id
    ///
    /// The Account ID used to send the request. This is an optional parameter that will be set automatically for operations that require it.
    pub fn account_id(mut self, value: impl Into<::std::string::String>) -> Self {
        self.account_id = Some(value.into());
        self
    }

    /// Sets the value for account_id
    ///
    /// The Account ID used to send the request. This is an optional parameter that will be set automatically for operations that require it.
    pub fn set_account_id(mut self, param: Option<::std::string::String>) -> Self {
        self.account_id = param;
        self
    }
    /// Sets the value for requires_account_id
    ///
    /// Internal parameter for operations that require account id host prefix.
    pub fn requires_account_id(mut self, value: impl Into<bool>) -> Self {
        self.requires_account_id = Some(value.into());
        self
    }

    /// Sets the value for requires_account_id
    ///
    /// Internal parameter for operations that require account id host prefix.
    pub fn set_requires_account_id(mut self, param: Option<bool>) -> Self {
        self.requires_account_id = param;
        self
    }
    /// Sets the value for outpost_id
    ///
    /// The Outpost ID.  Some operations have an optional OutpostId which should be used in endpoint construction.
    pub fn outpost_id(mut self, value: impl Into<::std::string::String>) -> Self {
        self.outpost_id = Some(value.into());
        self
    }

    /// Sets the value for outpost_id
    ///
    /// The Outpost ID.  Some operations have an optional OutpostId which should be used in endpoint construction.
    pub fn set_outpost_id(mut self, param: Option<::std::string::String>) -> Self {
        self.outpost_id = param;
        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 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 access_point_name
    ///
    /// The S3 AccessPointName used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 AccessPoint.
    pub fn access_point_name(mut self, value: impl Into<::std::string::String>) -> Self {
        self.access_point_name = Some(value.into());
        self
    }

    /// Sets the value for access_point_name
    ///
    /// The S3 AccessPointName used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 AccessPoint.
    pub fn set_access_point_name(mut self, param: Option<::std::string::String>) -> Self {
        self.access_point_name = 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 resource_arn
    ///
    /// The resource ARN included in the request.  Only set on TagResource, UntagResourceand ListTagsForResource
    pub fn resource_arn(mut self, value: impl Into<::std::string::String>) -> Self {
        self.resource_arn = Some(value.into());
        self
    }

    /// Sets the value for resource_arn
    ///
    /// The resource ARN included in the request.  Only set on TagResource, UntagResourceand ListTagsForResource
    pub fn set_resource_arn(mut self, param: Option<::std::string::String>) -> Self {
        self.resource_arn = param;
        self
    }
    /// Sets the value for use_s3_express_control_endpoint
    ///
    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. ListDirectoryAccessPoints)
    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. ListDirectoryAccessPoints)
    pub fn set_use_s3_express_control_endpoint(mut self, param: Option<bool>) -> Self {
        self.use_s3_express_control_endpoint = 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 {}