• Home
• software.amazon.awssdk
• s3
• 2.22.9
• source code
• DefaultS3EndpointProvider.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

software.amazon.awssdk.services.s3.endpoints.internal.DefaultS3EndpointProvider Maven / Gradle / Ivy

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
 * the License. A copy of the License is located at
 * 
 * http://aws.amazon.com/apache2.0
 * 
 * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
 * and limitations under the License.
 */

package software.amazon.awssdk.services.s3.endpoints.internal;

import java.net.URI;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.endpoints.Endpoint;
import software.amazon.awssdk.services.s3.endpoints.S3EndpointParams;
import software.amazon.awssdk.services.s3.endpoints.S3EndpointProvider;
import software.amazon.awssdk.utils.CompletableFutureUtils;
import software.amazon.awssdk.utils.Logger;
import software.amazon.awssdk.utils.MapUtils;
import software.amazon.awssdk.utils.Validate;

@Generated("software.amazon.awssdk:codegen")
@SdkInternalApi
public final class DefaultS3EndpointProvider implements S3EndpointProvider {
    private static final Logger LOG = Logger.loggerFor(DefaultS3EndpointProvider.class);

    private static final EndpointRuleset ENDPOINT_RULE_SET = ruleSet();

    private final EndpointAuthSchemeStrategy endpointAuthSchemeStrategy;

    public DefaultS3EndpointProvider() {
        EndpointAuthSchemeStrategyFactory endpointAuthSchemeStrategyFactory = new S3EndpointAuthSchemeStrategyFactory();
        this.endpointAuthSchemeStrategy = endpointAuthSchemeStrategyFactory.endpointAuthSchemeStrategy();
    }

    @Override
    public CompletableFuture resolveEndpoint(S3EndpointParams endpointParams) {
        Validate.notNull(endpointParams.useFips(), "Parameter 'UseFIPS' must not be null");
        Validate.notNull(endpointParams.useDualStack(), "Parameter 'UseDualStack' must not be null");
        Validate.notNull(endpointParams.forcePathStyle(), "Parameter 'ForcePathStyle' must not be null");
        Validate.notNull(endpointParams.accelerate(), "Parameter 'Accelerate' must not be null");
        Validate.notNull(endpointParams.useGlobalEndpoint(), "Parameter 'UseGlobalEndpoint' must not be null");
        Validate.notNull(endpointParams.disableMultiRegionAccessPoints(),
                "Parameter 'DisableMultiRegionAccessPoints' must not be null");
        Value res = new DefaultRuleEngine().evaluate(ENDPOINT_RULE_SET, toIdentifierValueMap(endpointParams));
        try {
            return CompletableFuture.completedFuture(valueAsEndpointOrThrow(res));
        } catch (Exception error) {
            return CompletableFutureUtils.failedFuture(error);
        }
    }

    private static Map toIdentifierValueMap(S3EndpointParams params) {
        Map paramsMap = new HashMap<>();
        if (params.bucket() != null) {
            paramsMap.put(Identifier.of("Bucket"), Value.fromStr(params.bucket()));
        }
        if (params.region() != null) {
            paramsMap.put(Identifier.of("Region"), Value.fromStr(params.region().id()));
        }
        if (params.useFips() != null) {
            paramsMap.put(Identifier.of("UseFIPS"), Value.fromBool(params.useFips()));
        }
        if (params.useDualStack() != null) {
            paramsMap.put(Identifier.of("UseDualStack"), Value.fromBool(params.useDualStack()));
        }
        if (params.endpoint() != null) {
            paramsMap.put(Identifier.of("Endpoint"), Value.fromStr(params.endpoint()));
        }
        if (params.forcePathStyle() != null) {
            paramsMap.put(Identifier.of("ForcePathStyle"), Value.fromBool(params.forcePathStyle()));
        }
        if (params.accelerate() != null) {
            paramsMap.put(Identifier.of("Accelerate"), Value.fromBool(params.accelerate()));
        }
        if (params.useGlobalEndpoint() != null) {
            paramsMap.put(Identifier.of("UseGlobalEndpoint"), Value.fromBool(params.useGlobalEndpoint()));
        }
        if (params.useObjectLambdaEndpoint() != null) {
            paramsMap.put(Identifier.of("UseObjectLambdaEndpoint"), Value.fromBool(params.useObjectLambdaEndpoint()));
        }
        if (params.key() != null) {
            paramsMap.put(Identifier.of("Key"), Value.fromStr(params.key()));
        }
        if (params.prefix() != null) {
            paramsMap.put(Identifier.of("Prefix"), Value.fromStr(params.prefix()));
        }
        if (params.disableAccessPoints() != null) {
            paramsMap.put(Identifier.of("DisableAccessPoints"), Value.fromBool(params.disableAccessPoints()));
        }
        if (params.disableMultiRegionAccessPoints() != null) {
            paramsMap.put(Identifier.of("DisableMultiRegionAccessPoints"),
                    Value.fromBool(params.disableMultiRegionAccessPoints()));
        }
        if (params.useArnRegion() != null) {
            paramsMap.put(Identifier.of("UseArnRegion"), Value.fromBool(params.useArnRegion()));
        }
        if (params.useS3ExpressControlEndpoint() != null) {
            paramsMap.put(Identifier.of("UseS3ExpressControlEndpoint"), Value.fromBool(params.useS3ExpressControlEndpoint()));
        }
        if (params.disableS3ExpressSessionAuth() != null) {
            paramsMap.put(Identifier.of("DisableS3ExpressSessionAuth"), Value.fromBool(params.disableS3ExpressSessionAuth()));
        }
        return paramsMap;
    }

    Endpoint valueAsEndpointOrThrow(Value value) {
        if (value instanceof Value.Endpoint) {
            Value.Endpoint endpoint = value.expectEndpoint();
            Endpoint.Builder builder = Endpoint.builder();
            builder.url(URI.create(endpoint.getUrl()));
            Map> headers = endpoint.getHeaders();
            if (headers != null) {
                headers.forEach((name, values) -> values.forEach(v -> builder.putHeader(name, v)));
            }
            addKnownProperties(builder, endpoint.getProperties());
            return builder.build();
        } else if (value instanceof Value.Str) {
            String errorMsg = value.expectString();
            if (errorMsg.contains("Invalid ARN") && errorMsg.contains(":s3:::")) {
                errorMsg += ". Use the bucket name instead of simple bucket ARNs in GetBucketLocationRequest.";
            }
            throw SdkClientException.create(errorMsg);
        } else {
            throw SdkClientException.create("Rule engine return neither an endpoint result or error value. Returned value was: "
                    + value);
        }
    }

    private static Rule endpointRule_1() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build()).error("Accelerate cannot be used with FIPS");
    }

    private static Rule endpointRule_2() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .error("Cannot set dual-stack in combination with a custom endpoint.");
    }

    private static Rule endpointRule_3() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build()).error("A custom endpoint cannot be combined with FIPS");
    }

    private static Rule endpointRule_4() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build()).error("A custom endpoint cannot be combined with S3 Accelerate");
    }

    private static Rule endpointRule_5() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("partitionResult").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("partitionResult")),
                                                                Expr.of("name"))).build().validate(), Expr.of("aws-cn"))).build()
                                        .validate()).build()).error("Partition does not support FIPS");
    }

    private static Rule endpointRule_7() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build()).error("S3Express does not support Dual-stack.");
    }

    private static Rule endpointRule_8() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build()).error("S3Express does not support S3 Accelerate.");
    }

    private static Rule endpointRule_13() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("{url#scheme}://{url#authority}/{uri_encoded_bucket}{url#path}"))
                        .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3express"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_12() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("uriEncode").argv(Arrays.asList(Expr.ref(Identifier.of("Bucket"))))
                                        .build().validate()).result("uri_encoded_bucket").build())
                .treeRule(Arrays.asList(endpointRule_13()));
    }

    private static Rule endpointRule_11() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder().fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("url")), Expr.of("isIp")))
                                                        .build().validate(), Expr.of(true))).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_12()));
    }

    private static Rule endpointRule_15() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("{url#scheme}://{Bucket}.{url#authority}{url#path}"))
                        .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3express"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_14() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.isVirtualHostableS3Bucket")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(false))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_15()));
    }

    private static Rule endpointRule_16() {
        return Rule.builder().error("S3Express bucket name is not a valid virtual hostable name.");
    }

    private static Rule endpointRule_10() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("DisableS3ExpressSessionAuth")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("DisableS3ExpressSessionAuth")), Expr.of(true)))
                                        .build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_11(), endpointRule_14(), endpointRule_16()));
    }

    private static Rule endpointRule_19() {
        return Rule.builder()
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}/{uri_encoded_bucket}{url#path}"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4-s3express"),
                                                Identifier.of("signingName"), Literal.fromStr("s3express"),
                                                Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_18() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("uriEncode").argv(Arrays.asList(Expr.ref(Identifier.of("Bucket"))))
                                        .build().validate()).result("uri_encoded_bucket").build())
                .treeRule(Arrays.asList(endpointRule_19()));
    }

    private static Rule endpointRule_17() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder().fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("url")), Expr.of("isIp")))
                                                        .build().validate(), Expr.of(true))).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_18()));
    }

    private static Rule endpointRule_21() {
        return Rule.builder()
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{Bucket}.{url#authority}{url#path}"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4-s3express"),
                                                Identifier.of("signingName"), Literal.fromStr("s3express"),
                                                Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_20() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.isVirtualHostableS3Bucket")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(false))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_21()));
    }

    private static Rule endpointRule_22() {
        return Rule.builder().error("S3Express bucket name is not a valid virtual hostable name.");
    }

    private static Rule endpointRule_9() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .treeRule(Arrays.asList(endpointRule_10(), endpointRule_17(), endpointRule_20(), endpointRule_22()));
    }

    private static Rule endpointRule_25() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3express-control-fips.{Region}.amazonaws.com/{uri_encoded_bucket}"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3express"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_26() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3express-control.{Region}.amazonaws.com/{uri_encoded_bucket}"))
                        .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3express"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_24() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("uriEncode").argv(Arrays.asList(Expr.ref(Identifier.of("Bucket"))))
                                        .build().validate()).result("uri_encoded_bucket").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_25(), endpointRule_26()));
    }

    private static Rule endpointRule_23() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseS3ExpressControlEndpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseS3ExpressControlEndpoint")), Expr.of(true)))
                                        .build().validate()).build()).treeRule(Arrays.asList(endpointRule_24()));
    }

    private static Rule endpointRule_30() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{Bucket}.s3express-fips-{s3expressAvailabilityZoneId}.{Region}.amazonaws.com"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3express"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_31() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.s3express-{s3expressAvailabilityZoneId}.{Region}.amazonaws.com"))
                        .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3express"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_29() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(6), Expr.of(14),
                                                Expr.of(true))).build().validate()).result("s3expressAvailabilityZoneId").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(14), Expr.of(16),
                                                Expr.of(true))).build().validate()).result("s3expressAvailabilityZoneDelim")
                                .build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("s3expressAvailabilityZoneDelim")),
                                                Expr.of("--"))).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_30(), endpointRule_31()));
    }

    private static Rule endpointRule_33() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{Bucket}.s3express-fips-{s3expressAvailabilityZoneId}.{Region}.amazonaws.com"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3express"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_34() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.s3express-{s3expressAvailabilityZoneId}.{Region}.amazonaws.com"))
                        .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3express"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_32() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(6), Expr.of(15),
                                                Expr.of(true))).build().validate()).result("s3expressAvailabilityZoneId").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(15), Expr.of(17),
                                                Expr.of(true))).build().validate()).result("s3expressAvailabilityZoneDelim")
                                .build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("s3expressAvailabilityZoneDelim")),
                                                Expr.of("--"))).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_33(), endpointRule_34()));
    }

    private static Rule endpointRule_35() {
        return Rule.builder().error("Unrecognized S3Express bucket name format.");
    }

    private static Rule endpointRule_28() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("DisableS3ExpressSessionAuth")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("DisableS3ExpressSessionAuth")), Expr.of(true)))
                                        .build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_29(), endpointRule_32(), endpointRule_35()));
    }

    private static Rule endpointRule_37() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{Bucket}.s3express-fips-{s3expressAvailabilityZoneId}.{Region}.amazonaws.com"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4-s3express"),
                                                Identifier.of("signingName"), Literal.fromStr("s3express"),
                                                Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_38() {
        return Rule.builder()
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3express-{s3expressAvailabilityZoneId}.{Region}.amazonaws.com"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4-s3express"),
                                                Identifier.of("signingName"), Literal.fromStr("s3express"),
                                                Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_36() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(6), Expr.of(14),
                                                Expr.of(true))).build().validate()).result("s3expressAvailabilityZoneId").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(14), Expr.of(16),
                                                Expr.of(true))).build().validate()).result("s3expressAvailabilityZoneDelim")
                                .build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("s3expressAvailabilityZoneDelim")),
                                                Expr.of("--"))).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_37(), endpointRule_38()));
    }

    private static Rule endpointRule_40() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{Bucket}.s3express-fips-{s3expressAvailabilityZoneId}.{Region}.amazonaws.com"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4-s3express"),
                                                Identifier.of("signingName"), Literal.fromStr("s3express"),
                                                Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_41() {
        return Rule.builder()
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3express-{s3expressAvailabilityZoneId}.{Region}.amazonaws.com"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4-s3express"),
                                                Identifier.of("signingName"), Literal.fromStr("s3express"),
                                                Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_39() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(6), Expr.of(15),
                                                Expr.of(true))).build().validate()).result("s3expressAvailabilityZoneId").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(15), Expr.of(17),
                                                Expr.of(true))).build().validate()).result("s3expressAvailabilityZoneDelim")
                                .build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("s3expressAvailabilityZoneDelim")),
                                                Expr.of("--"))).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_40(), endpointRule_41()));
    }

    private static Rule endpointRule_42() {
        return Rule.builder().error("Unrecognized S3Express bucket name format.");
    }

    private static Rule endpointRule_27() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.isVirtualHostableS3Bucket")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(false))).build()
                                        .validate()).build())
                .treeRule(Arrays.asList(endpointRule_28(), endpointRule_36(), endpointRule_39(), endpointRule_42()));
    }

    private static Rule endpointRule_43() {
        return Rule.builder().error("S3Express bucket name is not a valid virtual hostable name.");
    }

    private static Rule endpointRule_6() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(0), Expr.of(6),
                                                Expr.of(true))).build().validate()).result("bucketSuffix").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketSuffix")), Expr.of("--x-s3"))).build()
                                        .validate()).build())
                .treeRule(
                        Arrays.asList(endpointRule_7(), endpointRule_8(), endpointRule_9(), endpointRule_23(), endpointRule_27(),
                                endpointRule_43()));
    }

    private static Rule endpointRule_45() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#path}"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3express"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_46() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3express-control-fips.{Region}.amazonaws.com"))
                                .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3express"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_47() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3express-control.{Region}.amazonaws.com"))
                        .addProperty(Identifier.of("backend"), Literal.fromStr("S3Express"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3express"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_44() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseS3ExpressControlEndpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseS3ExpressControlEndpoint")), Expr.of(true)))
                                        .build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_45(), endpointRule_46(), endpointRule_47()));
    }

    private static Rule endpointRule_52() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .error("Expected a endpoint to be specified but no endpoint was found");
    }

    private static Rule endpointRule_53() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.ec2.{url#authority}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3-outposts"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_51() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("regionPrefix")), Expr.of("beta"))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_52(), endpointRule_53()));
    }

    private static Rule endpointRule_54() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.ec2.s3-outposts.{Region}.{regionPartition#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3-outposts"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_50() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("hardwareType")), Expr.of("e"))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_51(), endpointRule_54()));
    }

    private static Rule endpointRule_57() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .error("Expected a endpoint to be specified but no endpoint was found");
    }

    private static Rule endpointRule_58() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.op-{outpostId}.{url#authority}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3-outposts"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_56() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("regionPrefix")), Expr.of("beta"))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_57(), endpointRule_58()));
    }

    private static Rule endpointRule_59() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.op-{outpostId}.s3-outposts.{Region}.{regionPartition#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3-outposts"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_55() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("hardwareType")), Expr.of("o"))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_56(), endpointRule_59()));
    }

    private static Rule endpointRule_60() {
        return Rule.builder().error("Unrecognized hardware type: \"Expected hardware type o or e but got {hardwareType}\"");
    }

    private static Rule endpointRule_49() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isValidHostLabel")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("outpostId")), Expr.of(false))).build()
                                        .validate()).build())
                .treeRule(Arrays.asList(endpointRule_50(), endpointRule_55(), endpointRule_60()));
    }

    private static Rule endpointRule_61() {
        return Rule.builder().error("Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`.");
    }

    private static Rule endpointRule_48() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(49), Expr.of(50),
                                                Expr.of(true))).build().validate()).result("hardwareType").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(8), Expr.of(12),
                                                Expr.of(true))).build().validate()).result("regionPrefix").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(0), Expr.of(7),
                                                Expr.of(true))).build().validate()).result("bucketAliasSuffix").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(32), Expr.of(49),
                                                Expr.of(true))).build().validate()).result("outpostId").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("regionPartition").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketAliasSuffix")), Expr.of("--op-s3")))
                                        .build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_49(), endpointRule_61()));
    }

    private static Rule endpointRule_63() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("isSet")
                                                .argv(Arrays.asList(FnNode.builder().fn("parseURL")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                                        .validate())).build().validate())).build().validate()).build())
                .error("Custom endpoint `{Endpoint}` was not a valid URI");
    }

    private static Rule endpointRule_67() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("partitionResult")),
                                                                Expr.of("name"))).build().validate(), Expr.of("aws-cn"))).build()
                                        .validate()).build()).error("S3 Accelerate cannot be used in this region");
    }

    private static Rule endpointRule_68() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3-fips.dualstack.us-east-1.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_70() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.s3-fips.dualstack.{Region}.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_69() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_70()));
    }

    private static Rule endpointRule_71() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3-fips.dualstack.{Region}.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_72() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3-fips.us-east-1.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_74() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.s3-fips.{Region}.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_73() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_74()));
    }

    private static Rule endpointRule_75() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3-fips.{Region}.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_76() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3-accelerate.dualstack.us-east-1.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_78() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.s3-accelerate.dualstack.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_77() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_78()));
    }

    private static Rule endpointRule_79() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3-accelerate.dualstack.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_80() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3.dualstack.us-east-1.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_82() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.s3.dualstack.{Region}.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_81() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_82()));
    }

    private static Rule endpointRule_83() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3.dualstack.{Region}.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_84() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder().fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("url")), Expr.of("isIp")))
                                                        .build().validate(), Expr.of(true))).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#normalizedPath}{Bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_85() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder().fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("url")), Expr.of("isIp")))
                                                        .build().validate(), Expr.of(false))).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{Bucket}.{url#authority}{url#path}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_87() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("us-east-1"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#normalizedPath}{Bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_88() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("{url#scheme}://{url#authority}{url#normalizedPath}{Bucket}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_86() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder().fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("url")), Expr.of("isIp")))
                                                        .build().validate(), Expr.of(true))).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_87(), endpointRule_88()));
    }

    private static Rule endpointRule_90() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("us-east-1"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{Bucket}.{url#authority}{url#path}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_91() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("{url#scheme}://{Bucket}.{url#authority}{url#path}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_89() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder().fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("url")), Expr.of("isIp")))
                                                        .build().validate(), Expr.of(false))).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_90(), endpointRule_91()));
    }

    private static Rule endpointRule_92() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder().fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("url")), Expr.of("isIp")))
                                                        .build().validate(), Expr.of(true))).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#normalizedPath}{Bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_93() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder().fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("url")), Expr.of("isIp")))
                                                        .build().validate(), Expr.of(false))).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{Bucket}.{url#authority}{url#path}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_94() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3-accelerate.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_96() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("us-east-1"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3-accelerate.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_97() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.s3-accelerate.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_95() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_96(), endpointRule_97()));
    }

    private static Rule endpointRule_98() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3-accelerate.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_99() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_101() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("us-east-1"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_102() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://{Bucket}.s3.{Region}.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_100() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_101(), endpointRule_102()));
    }

    private static Rule endpointRule_103() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{Bucket}.s3.{Region}.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_66() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isValidHostLabel")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of(false))).build()
                                        .validate()).build())
                .treeRule(
                        Arrays.asList(endpointRule_67(), endpointRule_68(), endpointRule_69(), endpointRule_71(),
                                endpointRule_72(), endpointRule_73(), endpointRule_75(), endpointRule_76(), endpointRule_77(),
                                endpointRule_79(), endpointRule_80(), endpointRule_81(), endpointRule_83(), endpointRule_84(),
                                endpointRule_85(), endpointRule_86(), endpointRule_89(), endpointRule_92(), endpointRule_93(),
                                endpointRule_94(), endpointRule_95(), endpointRule_98(), endpointRule_99(), endpointRule_100(),
                                endpointRule_103()));
    }

    private static Rule endpointRule_104() {
        return Rule.builder().error("Invalid region: region was not a valid DNS name.");
    }

    private static Rule endpointRule_65() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("partitionResult").build())
                .treeRule(Arrays.asList(endpointRule_66(), endpointRule_104()));
    }

    private static Rule endpointRule_64() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("ForcePathStyle")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.isVirtualHostableS3Bucket")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(false))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_65()));
    }

    private static Rule endpointRule_108() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("{url#scheme}://{Bucket}.{url#authority}{url#path}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_107() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isValidHostLabel")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of(false))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_108()));
    }

    private static Rule endpointRule_109() {
        return Rule.builder().error("Invalid region: region was not a valid DNS name.");
    }

    private static Rule endpointRule_106() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("partitionResult").build())
                .treeRule(Arrays.asList(endpointRule_107(), endpointRule_109()));
    }

    private static Rule endpointRule_105() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder().fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("url")), Expr.of("scheme")))
                                                        .build().validate(), Expr.of("http"))).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.isVirtualHostableS3Bucket")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(true))).build().validate())
                                .build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("ForcePathStyle")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_106()));
    }

    private static Rule endpointRule_115() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 Object Lambda does not support Dual-stack");
    }

    private static Rule endpointRule_116() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 Object Lambda does not support S3 Accelerate");
    }

    private static Rule endpointRule_118() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("DisableAccessPoints")))).build().validate())
                                .build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("DisableAccessPoints")), Expr.of(true)))
                                        .build().validate()).build()).error("Access points are not supported for this operation");
    }

    private static Rule endpointRule_120() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("UseArnRegion"))))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseArnRegion")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("stringEquals")
                                                .argv(Arrays.asList(
                                                        FnNode.builder()
                                                                .fn("getAttr")
                                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                        Expr.of("region"))).build().validate(),
                                                        Expr.of("{Region}"))).build().validate())).build().validate()).build())
                .error("Invalid configuration: region from ARN `{bucketArn#region}` does not match client region `{Region}` and UseArnRegion is `false`");
    }

    private static Rule endpointRule_125() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("accountId"))).build().validate(), Expr.of(""))).build()
                                        .validate()).build()).error("Invalid ARN: Missing account id");
    }

    private static Rule endpointRule_128() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{accessPointName}-{bucketArn#accountId}.{url#authority}{url#path}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3-object-lambda"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_129() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{accessPointName}-{bucketArn#accountId}.s3-object-lambda-fips.{bucketArn#region}.{bucketPartition#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3-object-lambda"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_130() {
        return Rule
                .builder()
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{accessPointName}-{bucketArn#accountId}.s3-object-lambda.{bucketArn#region}.{bucketPartition#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3-object-lambda"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_127() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isValidHostLabel")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("accessPointName")), Expr.of(false))).build()
                                        .validate()).build())
                .treeRule(Arrays.asList(endpointRule_128(), endpointRule_129(), endpointRule_130()));
    }

    private static Rule endpointRule_131() {
        return Rule.builder().error(
                "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `{accessPointName}`");
    }

    private static Rule endpointRule_126() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("isValidHostLabel")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("accountId"))).build().validate(), Expr.of(false)))
                                        .build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_127(), endpointRule_131()));
    }

    private static Rule endpointRule_132() {
        return Rule.builder().error(
                "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `{bucketArn#accountId}`");
    }

    private static Rule endpointRule_124() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("isValidHostLabel")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("region"))).build().validate(), Expr.of(true))).build()
                                        .validate()).build())
                .treeRule(Arrays.asList(endpointRule_125(), endpointRule_126(), endpointRule_132()));
    }

    private static Rule endpointRule_133() {
        return Rule.builder().error("Invalid region in ARN: `{bucketArn#region}` (invalid DNS name)");
    }

    private static Rule endpointRule_123() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketPartition")),
                                                                Expr.of("name"))).build().validate(),
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("partitionResult")),
                                                                Expr.of("name"))).build().validate())).build().validate())
                                .build()).treeRule(Arrays.asList(endpointRule_124(), endpointRule_133()));
    }

    private static Rule endpointRule_134() {
        return Rule.builder().error(
                "Client was configured for partition `{partitionResult#name}` but ARN (`{Bucket}`) has `{bucketPartition#name}`");
    }

    private static Rule endpointRule_122() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("partitionResult").build())
                .treeRule(Arrays.asList(endpointRule_123(), endpointRule_134()));
    }

    private static Rule endpointRule_121() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("aws.partition")
                                        .argv(Arrays.asList(FnNode.builder().fn("getAttr")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")), Expr.of("region")))
                                                .build().validate())).build().validate()).result("bucketPartition").build())
                .treeRule(Arrays.asList(endpointRule_122()));
    }

    private static Rule endpointRule_119() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("isSet")
                                                .argv(Arrays.asList(FnNode
                                                        .builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("resourceId[2]"))).build().validate())).build()
                                                .validate())).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_120(), endpointRule_121()));
    }

    private static Rule endpointRule_135() {
        return Rule.builder().error("Invalid ARN: The ARN may only contain a single resource component after `accesspoint`.");
    }

    private static Rule endpointRule_117() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("stringEquals")
                                                .argv(Arrays.asList(
                                                        FnNode.builder()
                                                                .fn("getAttr")
                                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                        Expr.of("region"))).build().validate(), Expr.of("")))
                                                .build().validate())).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_118(), endpointRule_119(), endpointRule_135()));
    }

    private static Rule endpointRule_136() {
        return Rule.builder().error("Invalid ARN: bucket ARN is missing a region");
    }

    private static Rule endpointRule_114() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("getAttr")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")), Expr.of("resourceId[1]")))
                                        .build().validate()).result("accessPointName").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("accessPointName")), Expr.of("")))
                                                .build().validate())).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_115(), endpointRule_116(), endpointRule_117(), endpointRule_136()));
    }

    private static Rule endpointRule_137() {
        return Rule.builder().error(
                "Invalid ARN: Expected a resource of the format `accesspoint:` but no name was provided");
    }

    private static Rule endpointRule_113() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("arnType")), Expr.of("accesspoint"))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_114(), endpointRule_137()));
    }

    private static Rule endpointRule_138() {
        return Rule.builder().error(
                "Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `{arnType}`");
    }

    private static Rule endpointRule_112() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("service"))).build().validate(),
                                                Expr.of("s3-object-lambda"))).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_113(), endpointRule_138()));
    }

    private static Rule endpointRule_144() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("DisableAccessPoints")))).build().validate())
                                .build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("DisableAccessPoints")), Expr.of(true)))
                                        .build().validate()).build()).error("Access points are not supported for this operation");
    }

    private static Rule endpointRule_146() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("UseArnRegion"))))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseArnRegion")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("stringEquals")
                                                .argv(Arrays.asList(
                                                        FnNode.builder()
                                                                .fn("getAttr")
                                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                        Expr.of("region"))).build().validate(),
                                                        Expr.of("{Region}"))).build().validate())).build().validate()).build())
                .error("Invalid configuration: region from ARN `{bucketArn#region}` does not match client region `{Region}` and UseArnRegion is `false`");
    }

    private static Rule endpointRule_154() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build()).error("Access Points do not support S3 Accelerate");
    }

    private static Rule endpointRule_155() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{accessPointName}-{bucketArn#accountId}.s3-accesspoint-fips.dualstack.{bucketArn#region}.{bucketPartition#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_156() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{accessPointName}-{bucketArn#accountId}.s3-accesspoint-fips.{bucketArn#region}.{bucketPartition#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_157() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{accessPointName}-{bucketArn#accountId}.s3-accesspoint.dualstack.{bucketArn#region}.{bucketPartition#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_158() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{accessPointName}-{bucketArn#accountId}.{url#authority}{url#path}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_159() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{accessPointName}-{bucketArn#accountId}.s3-accesspoint.{bucketArn#region}.{bucketPartition#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_153() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isValidHostLabel")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("accessPointName")), Expr.of(false))).build()
                                        .validate()).build())
                .treeRule(
                        Arrays.asList(endpointRule_154(), endpointRule_155(), endpointRule_156(), endpointRule_157(),
                                endpointRule_158(), endpointRule_159()));
    }

    private static Rule endpointRule_160() {
        return Rule.builder().error(
                "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `{accessPointName}`");
    }

    private static Rule endpointRule_152() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("isValidHostLabel")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("accountId"))).build().validate(), Expr.of(false)))
                                        .build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_153(), endpointRule_160()));
    }

    private static Rule endpointRule_161() {
        return Rule.builder().error(
                "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `{bucketArn#accountId}`");
    }

    private static Rule endpointRule_151() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("service"))).build().validate(), Expr.of("s3"))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_152(), endpointRule_161()));
    }

    private static Rule endpointRule_162() {
        return Rule.builder().error("Invalid ARN: The ARN was not for the S3 service, found: {bucketArn#service}");
    }

    private static Rule endpointRule_150() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("isValidHostLabel")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("region"))).build().validate(), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_151(), endpointRule_162()));
    }

    private static Rule endpointRule_163() {
        return Rule.builder().error("Invalid region in ARN: `{bucketArn#region}` (invalid DNS name)");
    }

    private static Rule endpointRule_149() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketPartition")),
                                                                Expr.of("name"))).build().validate(),
                                                Expr.of("{partitionResult#name}"))).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_150(), endpointRule_163()));
    }

    private static Rule endpointRule_164() {
        return Rule.builder().error(
                "Client was configured for partition `{partitionResult#name}` but ARN (`{Bucket}`) has `{bucketPartition#name}`");
    }

    private static Rule endpointRule_148() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("partitionResult").build())
                .treeRule(Arrays.asList(endpointRule_149(), endpointRule_164()));
    }

    private static Rule endpointRule_147() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("aws.partition")
                                        .argv(Arrays.asList(FnNode.builder().fn("getAttr")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")), Expr.of("region")))
                                                .build().validate())).build().validate()).result("bucketPartition").build())
                .treeRule(Arrays.asList(endpointRule_148()));
    }

    private static Rule endpointRule_145() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("isSet")
                                                .argv(Arrays.asList(FnNode
                                                        .builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("resourceId[2]"))).build().validate())).build()
                                                .validate())).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_146(), endpointRule_147()));
    }

    private static Rule endpointRule_165() {
        return Rule.builder().error("Invalid ARN: The ARN may only contain a single resource component after `accesspoint`.");
    }

    private static Rule endpointRule_143() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("stringEquals")
                                                .argv(Arrays.asList(
                                                        FnNode.builder()
                                                                .fn("getAttr")
                                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                        Expr.of("region"))).build().validate(), Expr.of("")))
                                                .build().validate())).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_144(), endpointRule_145(), endpointRule_165()));
    }

    private static Rule endpointRule_142() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("arnType")), Expr.of("accesspoint"))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_143()));
    }

    private static Rule endpointRule_141() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("stringEquals")
                                                .argv(Arrays.asList(
                                                        FnNode.builder()
                                                                .fn("getAttr")
                                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                        Expr.of("region"))).build().validate(), Expr.of("")))
                                                .build().validate())).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_142()));
    }

    private static Rule endpointRule_167() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 MRAP does not support dual-stack");
    }

    private static Rule endpointRule_168() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 MRAP does not support FIPS");
    }

    private static Rule endpointRule_169() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 MRAP does not support S3 Accelerate");
    }

    private static Rule endpointRule_170() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("DisableMultiRegionAccessPoints")),
                                                Expr.of(true))).build().validate()).build())
                .error("Invalid configuration: Multi-Region Access Point ARNs are disabled.");
    }

    private static Rule endpointRule_173() {
        return Rule.builder()
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{accessPointName}.accesspoint.s3-global.{mrapPartition#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4a"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegionSet"),
                                                Literal.fromTuple(Arrays.asList(Literal.fromStr("*")))))))).build());
    }

    private static Rule endpointRule_172() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("mrapPartition")),
                                                                Expr.of("name"))).build().validate(),
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("partition"))).build().validate())).build().validate())
                                .build()).treeRule(Arrays.asList(endpointRule_173()));
    }

    private static Rule endpointRule_174() {
        return Rule
                .builder()
                .error("Client was configured for partition `{mrapPartition#name}` but bucket referred to partition `{bucketArn#partition}`");
    }

    private static Rule endpointRule_171() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("mrapPartition").build())
                .treeRule(Arrays.asList(endpointRule_172(), endpointRule_174()));
    }

    private static Rule endpointRule_166() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isValidHostLabel")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("accessPointName")), Expr.of(true))).build()
                                        .validate()).build())
                .treeRule(
                        Arrays.asList(endpointRule_167(), endpointRule_168(), endpointRule_169(), endpointRule_170(),
                                endpointRule_171()));
    }

    private static Rule endpointRule_175() {
        return Rule.builder().error("Invalid Access Point Name");
    }

    private static Rule endpointRule_140() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("getAttr")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")), Expr.of("resourceId[1]")))
                                        .build().validate()).result("accessPointName").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("accessPointName")), Expr.of("")))
                                                .build().validate())).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_141(), endpointRule_166(), endpointRule_175()));
    }

    private static Rule endpointRule_176() {
        return Rule.builder().error(
                "Invalid ARN: Expected a resource of the format `accesspoint:` but no name was provided");
    }

    private static Rule endpointRule_139() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("arnType")), Expr.of("accesspoint"))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_140(), endpointRule_176()));
    }

    private static Rule endpointRule_178() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 Outposts does not support Dual-stack");
    }

    private static Rule endpointRule_179() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 Outposts does not support FIPS");
    }

    private static Rule endpointRule_180() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 Outposts does not support S3 Accelerate");
    }

    private static Rule endpointRule_181() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("isSet")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("getAttr")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                        Expr.of("resourceId[4]"))).build().validate())).build().validate())
                                .build()).error("Invalid Arn: Outpost Access Point ARN contains sub resources");
    }

    private static Rule endpointRule_184() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("UseArnRegion"))))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseArnRegion")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("stringEquals")
                                                .argv(Arrays.asList(
                                                        FnNode.builder()
                                                                .fn("getAttr")
                                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                        Expr.of("region"))).build().validate(),
                                                        Expr.of("{Region}"))).build().validate())).build().validate()).build())
                .error("Invalid configuration: region from ARN `{bucketArn#region}` does not match client region `{Region}` and UseArnRegion is `false`");
    }

    private static Rule endpointRule_193() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://{accessPointName}-{bucketArn#accountId}.{outpostId}.{url#authority}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3-outposts"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_194() {
        return Rule
                .builder()
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://{accessPointName}-{bucketArn#accountId}.{outpostId}.s3-outposts.{bucketArn#region}.{bucketPartition#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3-outposts"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{bucketArn#region}")))))).build());
    }

    private static Rule endpointRule_192() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("outpostType")), Expr.of("accesspoint")))
                                        .build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_193(), endpointRule_194()));
    }

    private static Rule endpointRule_195() {
        return Rule.builder().error("Expected an outpost type `accesspoint`, found {outpostType}");
    }

    private static Rule endpointRule_191() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("getAttr")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")), Expr.of("resourceId[3]")))
                                        .build().validate()).result("accessPointName").build())
                .treeRule(Arrays.asList(endpointRule_192(), endpointRule_195()));
    }

    private static Rule endpointRule_196() {
        return Rule.builder().error("Invalid ARN: expected an access point name");
    }

    private static Rule endpointRule_190() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("getAttr")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")), Expr.of("resourceId[2]")))
                                        .build().validate()).result("outpostType").build())
                .treeRule(Arrays.asList(endpointRule_191(), endpointRule_196()));
    }

    private static Rule endpointRule_197() {
        return Rule.builder().error("Invalid ARN: Expected a 4-component resource");
    }

    private static Rule endpointRule_189() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("isValidHostLabel")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("accountId"))).build().validate(), Expr.of(false)))
                                        .build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_190(), endpointRule_197()));
    }

    private static Rule endpointRule_198() {
        return Rule.builder().error(
                "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `{bucketArn#accountId}`");
    }

    private static Rule endpointRule_188() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("isValidHostLabel")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("region"))).build().validate(), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_189(), endpointRule_198()));
    }

    private static Rule endpointRule_199() {
        return Rule.builder().error("Invalid region in ARN: `{bucketArn#region}` (invalid DNS name)");
    }

    private static Rule endpointRule_187() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketPartition")),
                                                                Expr.of("name"))).build().validate(),
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("partitionResult")),
                                                                Expr.of("name"))).build().validate())).build().validate())
                                .build()).treeRule(Arrays.asList(endpointRule_188(), endpointRule_199()));
    }

    private static Rule endpointRule_200() {
        return Rule.builder().error(
                "Client was configured for partition `{partitionResult#name}` but ARN (`{Bucket}`) has `{bucketPartition#name}`");
    }

    private static Rule endpointRule_186() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("partitionResult").build())
                .treeRule(Arrays.asList(endpointRule_187(), endpointRule_200()));
    }

    private static Rule endpointRule_185() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("aws.partition")
                                        .argv(Arrays.asList(FnNode.builder().fn("getAttr")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")), Expr.of("region")))
                                                .build().validate())).build().validate()).result("bucketPartition").build())
                .treeRule(Arrays.asList(endpointRule_186()));
    }

    private static Rule endpointRule_183() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isValidHostLabel")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("outpostId")), Expr.of(false))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_184(), endpointRule_185()));
    }

    private static Rule endpointRule_201() {
        return Rule.builder().error("Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `{outpostId}`");
    }

    private static Rule endpointRule_182() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("getAttr")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")), Expr.of("resourceId[1]")))
                                        .build().validate()).result("outpostId").build())
                .treeRule(Arrays.asList(endpointRule_183(), endpointRule_201()));
    }

    private static Rule endpointRule_202() {
        return Rule.builder().error("Invalid ARN: The Outpost Id was not set");
    }

    private static Rule endpointRule_177() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("stringEquals")
                                        .argv(Arrays.asList(
                                                FnNode.builder()
                                                        .fn("getAttr")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")),
                                                                Expr.of("service"))).build().validate(), Expr.of("s3-outposts")))
                                        .build().validate()).build())
                .treeRule(
                        Arrays.asList(endpointRule_178(), endpointRule_179(), endpointRule_180(), endpointRule_181(),
                                endpointRule_182(), endpointRule_202()));
    }

    private static Rule endpointRule_203() {
        return Rule.builder().error("Invalid ARN: Unrecognized format: {Bucket} (type: {arnType})");
    }

    private static Rule endpointRule_111() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("getAttr")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("bucketArn")), Expr.of("resourceId[0]")))
                                        .build().validate()).result("arnType").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("arnType")), Expr.of(""))).build()
                                                .validate())).build().validate()).build())
                .treeRule(Arrays.asList(endpointRule_112(), endpointRule_139(), endpointRule_177(), endpointRule_203()));
    }

    private static Rule endpointRule_204() {
        return Rule.builder().error("Invalid ARN: No ARN type specified");
    }

    private static Rule endpointRule_110() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("ForcePathStyle")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.parseArn").argv(Arrays.asList(Expr.ref(Identifier.of("Bucket"))))
                                        .build().validate()).result("bucketArn").build())
                .treeRule(Arrays.asList(endpointRule_111(), endpointRule_204()));
    }

    private static Rule endpointRule_205() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("substring")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")), Expr.of(0), Expr.of(4),
                                                Expr.of(false))).build().validate()).result("arnPrefix").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("arnPrefix")), Expr.of("arn:"))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode
                                                .builder()
                                                .fn("isSet")
                                                .argv(Arrays.asList(FnNode.builder().fn("aws.parseArn")
                                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")))).build()
                                                        .validate())).build().validate())).build().validate()).build())
                .error("Invalid ARN: `{Bucket}` was not a valid ARN");
    }

    private static Rule endpointRule_206() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("ForcePathStyle")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.parseArn").argv(Arrays.asList(Expr.ref(Identifier.of("Bucket"))))
                                        .build().validate()).build())
                .error("Path-style addressing cannot be used with ARN buckets");
    }

    private static Rule endpointRule_210() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://s3-fips.dualstack.us-east-1.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_212() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3-fips.dualstack.{Region}.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_211() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_212()));
    }

    private static Rule endpointRule_213() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr
                                        .of("https://s3-fips.dualstack.{Region}.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_214() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3-fips.us-east-1.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_216() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3-fips.{Region}.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_215() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_216()));
    }

    private static Rule endpointRule_217() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3-fips.{Region}.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_218() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.dualstack.us-east-1.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_220() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3.dualstack.{Region}.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_219() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_220()));
    }

    private static Rule endpointRule_221() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.dualstack.{Region}.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_222() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#normalizedPath}{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_224() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("us-east-1"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#normalizedPath}{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_225() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("{url#scheme}://{url#authority}{url#normalizedPath}{uri_encoded_bucket}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_223() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_224(), endpointRule_225()));
    }

    private static Rule endpointRule_226() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#normalizedPath}{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_227() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_229() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("us-east-1"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_230() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3.{Region}.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_228() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_229(), endpointRule_230()));
    }

    private static Rule endpointRule_231() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.{Region}.{partitionResult#dnsSuffix}/{uri_encoded_bucket}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_209() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(false))).build()
                                        .validate()).build())
                .treeRule(
                        Arrays.asList(endpointRule_210(), endpointRule_211(), endpointRule_213(), endpointRule_214(),
                                endpointRule_215(), endpointRule_217(), endpointRule_218(), endpointRule_219(),
                                endpointRule_221(), endpointRule_222(), endpointRule_223(), endpointRule_226(),
                                endpointRule_227(), endpointRule_228(), endpointRule_231()));
    }

    private static Rule endpointRule_232() {
        return Rule.builder().error("Path-style addressing cannot be used with S3 Accelerate");
    }

    private static Rule endpointRule_208() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("partitionResult").build())
                .treeRule(Arrays.asList(endpointRule_209(), endpointRule_232()));
    }

    private static Rule endpointRule_207() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("uriEncode").argv(Arrays.asList(Expr.ref(Identifier.of("Bucket"))))
                                        .build().validate()).result("uri_encoded_bucket").build())
                .treeRule(Arrays.asList(endpointRule_208()));
    }

    private static Rule endpointRule_62() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")))).build()
                                        .validate()).build())
                .treeRule(
                        Arrays.asList(endpointRule_63(), endpointRule_64(), endpointRule_105(), endpointRule_110(),
                                endpointRule_205(), endpointRule_206(), endpointRule_207()));
    }

    private static Rule endpointRule_236() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 Object Lambda does not support Dual-stack");
    }

    private static Rule endpointRule_237() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Accelerate")), Expr.of(true))).build()
                                        .validate()).build()).error("S3 Object Lambda does not support S3 Accelerate");
    }

    private static Rule endpointRule_238() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#path}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3-object-lambda"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_239() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3-object-lambda-fips.{Region}.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3-object-lambda"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_240() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3-object-lambda.{Region}.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                        Literal.fromStr("s3-object-lambda"), Identifier.of("signingRegion"),
                                        Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_235() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isValidHostLabel")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of(true))).build().validate())
                                .build())
                .treeRule(
                        Arrays.asList(endpointRule_236(), endpointRule_237(), endpointRule_238(), endpointRule_239(),
                                endpointRule_240()));
    }

    private static Rule endpointRule_241() {
        return Rule.builder().error("Invalid region: region was not a valid DNS name.");
    }

    private static Rule endpointRule_234() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("partitionResult").build())
                .treeRule(Arrays.asList(endpointRule_235(), endpointRule_241()));
    }

    private static Rule endpointRule_233() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseObjectLambdaEndpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseObjectLambdaEndpoint")), Expr.of(true)))
                                        .build().validate()).build()).treeRule(Arrays.asList(endpointRule_234()));
    }

    private static Rule endpointRule_245() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3-fips.dualstack.us-east-1.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_247() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3-fips.dualstack.{Region}.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_246() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_247()));
    }

    private static Rule endpointRule_248() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3-fips.dualstack.{Region}.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_249() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3-fips.us-east-1.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_251() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3-fips.{Region}.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_250() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_251()));
    }

    private static Rule endpointRule_252() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3-fips.{Region}.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_253() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.dualstack.us-east-1.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_255() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3.dualstack.{Region}.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_254() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_255()));
    }

    private static Rule endpointRule_256() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(true))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.dualstack.{Region}.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_257() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#path}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_259() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("us-east-1"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#path}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_260() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("{url#scheme}://{url#authority}{url#path}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_258() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_259(), endpointRule_260()));
    }

    private static Rule endpointRule_261() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("parseURL").argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint"))))
                                        .build().validate()).result("url").build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("{url#scheme}://{url#authority}{url#path}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_262() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("us-east-1")))))).build());
    }

    private static Rule endpointRule_264() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("stringEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("us-east-1"))).build()
                                        .validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_265() {
        return Rule.builder().endpoint(
                EndpointResult
                        .builder()
                        .url(Expr.of("https://s3.{Region}.{partitionResult#dnsSuffix}"))
                        .addProperty(
                                Identifier.of("authSchemes"),
                                Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                        Identifier.of("disableDoubleEncoding"), Literal.fromBool(true), Identifier.of("name"),
                                        Literal.fromStr("sigv4"), Identifier.of("signingName"), Literal.fromStr("s3"),
                                        Identifier.of("signingRegion"), Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_263() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(true))).build()
                                        .validate()).build()).treeRule(Arrays.asList(endpointRule_264(), endpointRule_265()));
    }

    private static Rule endpointRule_266() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseFIPS")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseDualStack")), Expr.of(false))).build()
                                        .validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Endpoint")))).build().validate()))
                                        .build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("stringEquals")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of("aws-global")))
                                                .build().validate())).build().validate()).build())
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("booleanEquals")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("UseGlobalEndpoint")), Expr.of(false)))
                                        .build().validate()).build())
                .endpoint(
                        EndpointResult
                                .builder()
                                .url(Expr.of("https://s3.{Region}.{partitionResult#dnsSuffix}"))
                                .addProperty(
                                        Identifier.of("authSchemes"),
                                        Literal.fromTuple(Arrays.asList(Literal.fromRecord(MapUtils.of(
                                                Identifier.of("disableDoubleEncoding"), Literal.fromBool(true),
                                                Identifier.of("name"), Literal.fromStr("sigv4"), Identifier.of("signingName"),
                                                Literal.fromStr("s3"), Identifier.of("signingRegion"),
                                                Literal.fromStr("{Region}")))))).build());
    }

    private static Rule endpointRule_244() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isValidHostLabel")
                                        .argv(Arrays.asList(Expr.ref(Identifier.of("Region")), Expr.of(true))).build().validate())
                                .build())
                .treeRule(
                        Arrays.asList(endpointRule_245(), endpointRule_246(), endpointRule_248(), endpointRule_249(),
                                endpointRule_250(), endpointRule_252(), endpointRule_253(), endpointRule_254(),
                                endpointRule_256(), endpointRule_257(), endpointRule_258(), endpointRule_261(),
                                endpointRule_262(), endpointRule_263(), endpointRule_266()));
    }

    private static Rule endpointRule_267() {
        return Rule.builder().error("Invalid region: region was not a valid DNS name.");
    }

    private static Rule endpointRule_243() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("aws.partition").argv(Arrays.asList(Expr.ref(Identifier.of("Region"))))
                                        .build().validate()).result("partitionResult").build())
                .treeRule(Arrays.asList(endpointRule_244(), endpointRule_267()));
    }

    private static Rule endpointRule_242() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode
                                        .builder()
                                        .fn("not")
                                        .argv(Arrays.asList(FnNode.builder().fn("isSet")
                                                .argv(Arrays.asList(Expr.ref(Identifier.of("Bucket")))).build().validate()))
                                        .build().validate()).build()).treeRule(Arrays.asList(endpointRule_243()));
    }

    private static Rule endpointRule_0() {
        return Rule
                .builder()
                .addCondition(
                        Condition
                                .builder()
                                .fn(FnNode.builder().fn("isSet").argv(Arrays.asList(Expr.ref(Identifier.of("Region")))).build()
                                        .validate()).build())
                .treeRule(
                        Arrays.asList(endpointRule_1(), endpointRule_2(), endpointRule_3(), endpointRule_4(), endpointRule_5(),
                                endpointRule_6(), endpointRule_44(), endpointRule_48(), endpointRule_62(), endpointRule_233(),
                                endpointRule_242()));
    }

    private static Rule endpointRule_268() {
        return Rule.builder().error("A region must be set when sending requests to S3.");
    }

    private static EndpointRuleset ruleSet() {
        return EndpointRuleset
                .builder()
                .version("1.0")
                .serviceId(null)
                .parameters(
                        Parameters
                                .builder()
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("Bucket")
                                                .type(ParameterType.fromValue("String"))
                                                .required(false)
                                                .documentation(
                                                        "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.")
                                                .build())
                                .addParameter(
                                        Parameter.builder().name("Region").type(ParameterType.fromValue("String"))
                                                .required(false).builtIn("AWS::Region")
                                                .documentation("The AWS region used to dispatch the request.").build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("UseFIPS")
                                                .type(ParameterType.fromValue("Boolean"))
                                                .required(true)
                                                .builtIn("AWS::UseFIPS")
                                                .documentation(
                                                        "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.")
                                                .defaultValue(Value.fromBool(false)).build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("UseDualStack")
                                                .type(ParameterType.fromValue("Boolean"))
                                                .required(true)
                                                .builtIn("AWS::UseDualStack")
                                                .documentation(
                                                        "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.")
                                                .defaultValue(Value.fromBool(false)).build())
                                .addParameter(
                                        Parameter.builder().name("Endpoint").type(ParameterType.fromValue("String"))
                                                .required(false).builtIn("SDK::Endpoint")
                                                .documentation("Override the endpoint used to send this request").build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("ForcePathStyle")
                                                .type(ParameterType.fromValue("Boolean"))
                                                .required(true)
                                                .builtIn("AWS::S3::ForcePathStyle")
                                                .documentation(
                                                        "When true, force a path-style endpoint to be used where the bucket name is part of the path.")
                                                .defaultValue(Value.fromBool(false)).build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("Accelerate")
                                                .type(ParameterType.fromValue("Boolean"))
                                                .required(true)
                                                .builtIn("AWS::S3::Accelerate")
                                                .documentation(
                                                        "When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.")
                                                .defaultValue(Value.fromBool(false)).build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("UseGlobalEndpoint")
                                                .type(ParameterType.fromValue("Boolean"))
                                                .required(true)
                                                .builtIn("AWS::S3::UseGlobalEndpoint")
                                                .documentation(
                                                        "Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.")
                                                .defaultValue(Value.fromBool(false)).build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("UseObjectLambdaEndpoint")
                                                .type(ParameterType.fromValue("Boolean"))
                                                .required(false)
                                                .documentation(
                                                        "Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)")
                                                .build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("Key")
                                                .type(ParameterType.fromValue("String"))
                                                .required(false)
                                                .documentation(
                                                        "The S3 Key used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Key.")
                                                .build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("Prefix")
                                                .type(ParameterType.fromValue("String"))
                                                .required(false)
                                                .documentation(
                                                        "The S3 Prefix used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Prefix.")
                                                .build())
                                .addParameter(
                                        Parameter.builder().name("DisableAccessPoints").type(ParameterType.fromValue("Boolean"))
                                                .required(false)
                                                .documentation("Internal parameter to disable Access Point Buckets").build())
                                .addParameter(
                                        Parameter.builder().name("DisableMultiRegionAccessPoints")
                                                .type(ParameterType.fromValue("Boolean")).required(true)
                                                .builtIn("AWS::S3::DisableMultiRegionAccessPoints")
                                                .documentation("Whether multi-region access points (MRAP) should be disabled.")
                                                .defaultValue(Value.fromBool(false)).build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("UseArnRegion")
                                                .type(ParameterType.fromValue("Boolean"))
                                                .required(false)
                                                .builtIn("AWS::S3::UseArnRegion")
                                                .documentation(
                                                        "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.")
                                                .build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("UseS3ExpressControlEndpoint")
                                                .type(ParameterType.fromValue("Boolean"))
                                                .required(false)
                                                .documentation(
                                                        "Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)")
                                                .build())
                                .addParameter(
                                        Parameter
                                                .builder()
                                                .name("DisableS3ExpressSessionAuth")
                                                .type(ParameterType.fromValue("Boolean"))
                                                .required(false)
                                                .documentation(
                                                        "Parameter to indicate whether S3Express session auth should be disabled")
                                                .build()).build()).addRule(endpointRule_0()).addRule(endpointRule_268()).build();
    }

    @Override
    public boolean equals(Object rhs) {
        return rhs != null && getClass().equals(rhs.getClass());
    }

    @Override
    public int hashCode() {
        return getClass().hashCode();
    }

    private  void addKnownProperty(EndpointAttributeProvider provider, Endpoint.Builder builder, Value value) {
        builder.putAttribute(provider.attributeKey(), provider.attributeValue(value));
    }

    private void addKnownProperties(Endpoint.Builder builder, Map properties) {
        List> knownProperties = software.amazon.awssdk.services.s3.endpoints.internal.KnownS3ExpressEndpointProperty.KNOWN_S3_ENDPOINT_PROPERTIES;
        for (EndpointAttributeProvider p : knownProperties) {
            if (properties.containsKey(p.propertyName())) {
                addKnownProperty(p, builder, properties.get(p.propertyName()));
            }
        }
    }
}