terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/route.js

@@ -0,0 +1,469 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f, _g, _h;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteTable = exports.Route = exports.RouteTargetType = exports.VPCPeeringConnection = exports.NatGateway = exports.VPNGatewayV2 = exports.InternetGateway = exports.EgressOnlyInternetGateway = exports.NatConnectivityType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/route.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const vpc_1 = require("./vpc");
+const vpc_endpoint_1 = require("./vpc-endpoint");
+const aws_construct_1 = require("../aws-construct");
+// TODO: Use TagManager and tag-aspect instead
+const aws_tags_1 = require("../aws-tags");
+// import { Tags } from "../tag-aspect";
+const ec2_util_1 = require("./ec2-util");
+const ec2_util_v2_1 = require("./ec2-util-v2");
+/**
+ * Indicates whether the NAT gateway supports public or private connectivity.
+ * The default is public connectivity.
+ * See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-connectivitytype
+ */
+var NatConnectivityType;
+(function (NatConnectivityType) {
+    /**
+     * Sets Connectivity type to PUBLIC
+     */
+    NatConnectivityType["PUBLIC"] = "public";
+    /**
+     * Sets Connectivity type to PRIVATE
+     */
+    NatConnectivityType["PRIVATE"] = "private";
+})(NatConnectivityType || (exports.NatConnectivityType = NatConnectivityType = {}));
+/**
+ * Name tag constant
+ */
+const NAME_TAG = "Name";
+/**
+ * Creates an egress-only internet gateway
+ * @resource aws_egress_only_internet_gateway
+ */
+class EgressOnlyInternetGateway extends aws_construct_1.AwsConstructBase {
+    get routeTargetOutputs() {
+        return {
+            routerType: this.routerType,
+            routerTargetId: this.routerTargetId,
+        };
+    }
+    get outputs() {
+        return this.routeTargetOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        if (props.egressOnlyInternetGatewayName) {
+            aws_tags_1.Tags.of(this).add(NAME_TAG, props.egressOnlyInternetGatewayName);
+        }
+        this.routerType = vpc_1.RouterType.EGRESS_ONLY_INTERNET_GATEWAY;
+        this.resource = new provider_aws_1.egressOnlyInternetGateway.EgressOnlyInternetGateway(this, "EIGW", {
+            vpcId: props.vpc.vpcId,
+        });
+        this.node.defaultChild = this.resource;
+        this.routerTargetId = this.resource.id;
+    }
+}
+exports.EgressOnlyInternetGateway = EgressOnlyInternetGateway;
+_a = JSII_RTTI_SYMBOL_1;
+EgressOnlyInternetGateway[_a] = { fqn: "terraconstructs.aws.compute.alpha.EgressOnlyInternetGateway", version: "0.0.12" };
+/**
+ * Creates an internet gateway
+ * @resource AWS::EC2::InternetGateway
+ */
+class InternetGateway extends aws_construct_1.AwsConstructBase {
+    get routeTargetOutputs() {
+        return {
+            routerType: this.routerType,
+            routerTargetId: this.routerTargetId,
+        };
+    }
+    get outputs() {
+        return this.routeTargetOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.routerType = vpc_1.RouterType.GATEWAY;
+        this.resource = new provider_aws_1.internetGateway.InternetGateway(this, "IGW", {});
+        this.node.defaultChild = this.resource;
+        this.routerTargetId = this.resource.id;
+        this.vpcId = props.vpc.vpcId;
+        if (props.internetGatewayName) {
+            aws_tags_1.Tags.of(this).add(NAME_TAG, props.internetGatewayName);
+        }
+        new provider_aws_1.internetGatewayAttachment.InternetGatewayAttachment(this, "GWAttachment", {
+            vpcId: this.vpcId,
+            internetGatewayId: this.routerTargetId,
+        });
+    }
+}
+exports.InternetGateway = InternetGateway;
+_b = JSII_RTTI_SYMBOL_1;
+InternetGateway[_b] = { fqn: "terraconstructs.aws.compute.alpha.InternetGateway", version: "0.0.12" };
+/**
+ * Creates a virtual private gateway
+ * @resource AWS::EC2::VPNGateway
+ */
+class VPNGatewayV2 extends aws_construct_1.AwsConstructBase {
+    get routeTargetOutputs() {
+        return {
+            routerType: this.routerType,
+            routerTargetId: this.routerTargetId,
+        };
+    }
+    get outputs() {
+        return this.routeTargetOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        /**
+         * The VPN Gateway Route Propagation
+         */
+        this._routePropagation = [];
+        const vpnGatewayName = props.vpnGatewayName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        this.routerType = vpc_1.RouterType.GATEWAY;
+        this.resource = new provider_aws_1.vpnGateway.VpnGateway(this, "IGW", {
+            amazonSideAsn: props.amazonSideAsn !== undefined
+                ? props.amazonSideAsn.toString()
+                : undefined,
+        });
+        this.node.defaultChild = this.resource;
+        this.routerTargetId = this.resource.id;
+        this.vpcId = props.vpc.vpcId;
+        this._attachment = new provider_aws_1.vpnGatewayAttachment.VpnGatewayAttachment(this, "VPCVPNGW", {
+            vpcId: this.vpcId,
+            vpnGatewayId: this.resource.id,
+        });
+        if (props.vpnGatewayName) {
+            aws_tags_1.Tags.of(this).add(NAME_TAG, vpnGatewayName);
+        }
+        // Propagate routes on route tables associated with the right subnets
+        const vpnRoutePropagation = props.vpnRoutePropagation ?? [];
+        const subnets = vpnRoutePropagation
+            .map((s) => props.vpc.selectSubnets(s).subnets)
+            .flat();
+        const routeTableIds = (0, ec2_util_1.allRouteTableIds)(subnets);
+        if (routeTableIds.length === 0) {
+            // "@aws-cdk:aws-ec2-elpha:enableVpnGatewayV2",
+            cdktf_1.Annotations.of(scope).addWarning(`No subnets matching selection: '${JSON.stringify(vpnRoutePropagation)}'. Select other subnets to add routes to.`);
+        }
+        for (let i = 0; i < subnets.length; i++) {
+            const routePropagation = new provider_aws_1.vpnGatewayRoutePropagation.VpnGatewayRoutePropagation(this, `RoutePropagation${i}`, {
+                routeTableId: subnets[i].routeTable.routeTableId,
+                vpnGatewayId: this.routerTargetId,
+            });
+            // The AWS::EC2::VPNGatewayRoutePropagation resource cannot use the VPN gateway
+            // until it has successfully attached to the VPC.
+            // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-gatewayrouteprop.html
+            routePropagation.node.addDependency(this._attachment);
+            this._routePropagation.push(routePropagation);
+        }
+    }
+}
+exports.VPNGatewayV2 = VPNGatewayV2;
+_c = JSII_RTTI_SYMBOL_1;
+VPNGatewayV2[_c] = { fqn: "terraconstructs.aws.compute.alpha.VPNGatewayV2", version: "0.0.12" };
+/**
+ * Creates a network address translation (NAT) gateway
+ * @resource AWS::EC2::NatGateway
+ */
+class NatGateway extends aws_construct_1.AwsConstructBase {
+    get routeTargetOutputs() {
+        return {
+            routerType: this.routerType,
+            routerTargetId: this.routerTargetId,
+        };
+    }
+    get outputs() {
+        return this.routeTargetOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.routerType = vpc_1.RouterType.NAT_GATEWAY;
+        this.connectivityType =
+            props.connectivityType || NatConnectivityType.PUBLIC;
+        this.maxDrainDuration = props.maxDrainDuration;
+        if (this.connectivityType === NatConnectivityType.PUBLIC) {
+            if (!props.vpc && !props.allocationId) {
+                throw new Error("Either provide vpc or allocationId");
+            }
+        }
+        if (props.natGatewayName) {
+            aws_tags_1.Tags.of(this).add(NAME_TAG, props?.natGatewayName);
+        }
+        // If user does not provide EIP, generate one for them
+        var aId;
+        if (this.connectivityType === NatConnectivityType.PUBLIC) {
+            if (!props.allocationId) {
+                let eip = new provider_aws_1.eip.Eip(this, "EIP", {
+                    domain: props.vpc?.vpcId,
+                });
+                aId = eip.allocationId;
+            }
+            else {
+                aId = props.allocationId;
+            }
+        }
+        this.resource = new provider_aws_1.natGateway.NatGateway(this, "NATGateway", {
+            subnetId: props.subnet.subnetId,
+            allocationId: aId,
+            privateIp: props.privateIpAddress,
+            // ...props,
+            connectivityType: props.connectivityType,
+            secondaryAllocationIds: props.secondaryAllocationIds,
+            secondaryPrivateIpAddressCount: props.secondaryPrivateIpAddressCount,
+            secondaryPrivateIpAddresses: props.secondaryPrivateIpAddresses,
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-maxdraindurationseconds
+            // https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/nat_gateway#timeouts
+            ...(this.maxDrainDuration
+                ? {
+                    timeouts: {
+                        delete: this.maxDrainDuration.toSeconds().toString(),
+                    },
+                }
+                : {}),
+        });
+        this.natGatewayId = this.resource.id;
+        this.routerTargetId = this.resource.id;
+        this.node.defaultChild = this.resource;
+        this.node.addDependency(props.subnet.internetConnectivityEstablished);
+    }
+}
+exports.NatGateway = NatGateway;
+_d = JSII_RTTI_SYMBOL_1;
+NatGateway[_d] = { fqn: "terraconstructs.aws.compute.alpha.NatGateway", version: "0.0.12" };
+/**
+ * Creates a peering connection between two VPCs
+ * @resource AWS::EC2::VPCPeeringConnection
+ */
+class VPCPeeringConnection extends aws_construct_1.AwsConstructBase {
+    get routeTargetOutputs() {
+        return {
+            routerType: this.routerType,
+            routerTargetId: this.routerTargetId,
+        };
+    }
+    get outputs() {
+        return this.routeTargetOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.routerType = vpc_1.RouterType.VPC_PEERING_CONNECTION;
+        // const isCrossAccount =
+        //   props.requestorVpc.ownerAccountId !== props.acceptorVpc.ownerAccountId;
+        // if (!isCrossAccount && props.peerRoleArn) {
+        //   throw new Error("peerRoleArn is not needed for same account peering");
+        // }
+        // if (isCrossAccount && !props.peerRoleArn) {
+        //   throw new Error("Cross account VPC peering requires peerRoleArn");
+        // }
+        const overlap = this.validateVpcCidrOverlap(props.requestorVpc, props.acceptorVpc);
+        if (overlap) {
+            throw new Error("CIDR block should not overlap with each other for establishing a peering connection");
+        }
+        if (props.vpcPeeringConnectionName) {
+            aws_tags_1.Tags.of(this).add(NAME_TAG, props.vpcPeeringConnectionName);
+        }
+        this.resource = new provider_aws_1.vpcPeeringConnection.VpcPeeringConnection(this, "VPCPeeringConnection", {
+            vpcId: props.requestorVpc.vpcId,
+            peerVpcId: props.acceptorVpc.vpcId,
+            peerOwnerId: props.acceptorVpc.ownerAccountId,
+            peerRegion: props.acceptorVpc.region, // autoAccept must be false
+            // TODO: handle crossAccount TF Provider for vpc_peering_connection_accepter
+            // peerRoleArn: isCrossAccount ? props.peerRoleArn : undefined,
+        });
+        // TODO: Add aws_vpc_peering_connection_accepter to manage Accepter Side?
+        this.routerTargetId = this.resource.id;
+        this.node.defaultChild = this.resource;
+    }
+    /**
+     * Validates if the provided IPv4 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.
+     *
+     * @param requestorVpc The VPC of the requestor.
+     * @param acceptorVpc The VPC of the acceptor.
+     * @returns True if the IPv4 CIDR block overlaps with each other for two VPCs, false otherwise.
+     * @internal
+     */
+    validateVpcCidrOverlap(requestorVpc, acceptorVpc) {
+        const requestorCidrs = [requestorVpc.ipv4CidrBlock];
+        const acceptorCidrs = [acceptorVpc.ipv4CidrBlock];
+        if (requestorVpc.secondaryCidrBlock) {
+            requestorCidrs.push(...requestorVpc.secondaryCidrBlock
+                .map((block) => block.cidrBlock)
+                .filter((cidr) => cidr !== undefined));
+        }
+        if (acceptorVpc.secondaryCidrBlock) {
+            acceptorCidrs.push(...acceptorVpc.secondaryCidrBlock
+                .map((block) => block.cidrBlock)
+                .filter((cidr) => cidr !== undefined));
+        }
+        for (const requestorCidr of requestorCidrs) {
+            const requestorRange = new ec2_util_v2_1.CidrBlock(requestorCidr);
+            const requestorIpRange = [
+                requestorRange.minIp(),
+                requestorRange.maxIp(),
+            ];
+            for (const acceptorCidr of acceptorCidrs) {
+                const acceptorRange = new ec2_util_v2_1.CidrBlock(acceptorCidr);
+                const acceptorIpRange = [
+                    acceptorRange.minIp(),
+                    acceptorRange.maxIp(),
+                ];
+                if (requestorRange.rangesOverlap(acceptorIpRange, requestorIpRange)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+exports.VPCPeeringConnection = VPCPeeringConnection;
+_e = JSII_RTTI_SYMBOL_1;
+VPCPeeringConnection[_e] = { fqn: "terraconstructs.aws.compute.alpha.VPCPeeringConnection", version: "0.0.12" };
+/**
+ * The gateway or endpoint targeted by the route.
+ */
+class RouteTargetType {
+    constructor(props) {
+        if ((props.gateway && props.endpoint) ||
+            (!props.gateway && !props.endpoint)) {
+            throw new Error("Exactly one of `gateway` or `endpoint` must be specified.");
+        }
+        else {
+            this.gateway = props.gateway;
+            this.endpoint = props.endpoint;
+        }
+    }
+}
+exports.RouteTargetType = RouteTargetType;
+_f = JSII_RTTI_SYMBOL_1;
+RouteTargetType[_f] = { fqn: "terraconstructs.aws.compute.alpha.RouteTargetType", version: "0.0.12" };
+/**
+ * Creates a new route with added functionality.
+ * @resource AWS::EC2::Route
+ */
+class Route extends aws_construct_1.AwsConstructBase {
+    get routeOutputs() {
+        return {
+            routeTable: this.routeTable.routeTableId,
+            destination: this.destination,
+            target: this.target.endpoint
+                ? this.target.endpoint.vpcEndpointOutputs
+                : this.target.gateway.routeTargetOutputs,
+        };
+    }
+    get outputs() {
+        return this.routeOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.target = props.target;
+        this.routeTable = props.routeTable;
+        this.destination = props.destination;
+        const isDestinationIpv4 = ec2_util_v2_1.NetworkUtils.validIp(props.destination);
+        if (!isDestinationIpv4) {
+            //TODO Validate for IPv6 CIDR range
+            this.destinationIpv6Cidr = props.destination;
+        }
+        else {
+            this.destinationIpv4Cidr = props.destination;
+        }
+        if (this.target.gateway?.routerType ===
+            vpc_1.RouterType.EGRESS_ONLY_INTERNET_GATEWAY &&
+            isDestinationIpv4) {
+            throw new Error("Egress only internet gateway does not support IPv4 routing");
+        }
+        this.targetRouterType = this.target.gateway
+            ? this.target.gateway.routerType
+            : vpc_1.RouterType.VPC_ENDPOINT;
+        // Gateway generates route automatically via its RouteTable, thus we don't need to generate the resource for it
+        if (!(this.target.endpoint instanceof vpc_endpoint_1.GatewayVpcEndpoint)) {
+            this.resource = new provider_aws_1.route.Route(this, "Route", {
+                routeTableId: this.routeTable.routeTableId,
+                destinationCidrBlock: this.destinationIpv4Cidr,
+                destinationIpv6CidrBlock: this.destinationIpv6Cidr,
+                [routerTypeToPropName(this.targetRouterType)]: this.target.gateway
+                    ? this.target.gateway.routerTargetId
+                    : this.target.endpoint
+                        ? this.target.endpoint.vpcEndpointId
+                        : null,
+            });
+        }
+        this.node.defaultChild = this.resource;
+        //Create a route only after target gateway or endpoint is created
+        if (this.target.gateway) {
+            this.node.addDependency(this.target.gateway);
+        }
+        if (this.target.endpoint) {
+            this.node.addDependency(this.target.endpoint);
+        }
+    }
+}
+exports.Route = Route;
+_g = JSII_RTTI_SYMBOL_1;
+Route[_g] = { fqn: "terraconstructs.aws.compute.alpha.Route", version: "0.0.12" };
+/**
+ * Creates a route table for the specified VPC
+ * @resource aws_route_table
+ */
+class RouteTable extends aws_construct_1.AwsConstructBase {
+    get routeTableOutputs() {
+        return {
+            routeTableId: this.routeTableId,
+        };
+    }
+    get outputs() {
+        return this.routeTableOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.resource = new provider_aws_1.routeTable.RouteTable(this, "RouteTable", {
+            vpcId: props.vpc.vpcId,
+        });
+        if (props.routeTableName) {
+            aws_tags_1.Tags.of(this).add(NAME_TAG, props.routeTableName);
+        }
+        this.node.defaultChild = this.resource;
+        this.routeTableId = this.resource.id;
+    }
+    /**
+     * Adds a new custom route to the route table.
+     *
+     * @param destination The IPv4 or IPv6 CIDR block used for the destination match.
+     * @param target The gateway or endpoint targeted by the route.
+     * @param routeName The resource name of the route.
+     */
+    addRoute(id, destination, target, routeName) {
+        new Route(this, id, {
+            routeTable: this,
+            destination: destination,
+            target: target,
+            routeName: routeName,
+        });
+    }
+}
+exports.RouteTable = RouteTable;
+_h = JSII_RTTI_SYMBOL_1;
+RouteTable[_h] = { fqn: "terraconstructs.aws.compute.alpha.RouteTable", version: "0.0.12" };
+/**
+ * inverse of
+ * https://github.com/hashicorp/terraform-provider-aws/blob/v5.87.0/internal/service/ec2/vpc_route.go#L219-L239
+ */
+function routerTypeToPropName(routerType) {
+    const lookupMap = {
+        [vpc_1.RouterType.CARRIER_GATEWAY]: "carrierGatewayId",
+        [vpc_1.RouterType.EGRESS_ONLY_INTERNET_GATEWAY]: "egressOnlyGatewayId",
+        [vpc_1.RouterType.GATEWAY]: "gatewayId",
+        // terraform-provider-aws is missing switch case for InstanceId
+        // https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateRoute.html
+        // [RouterType.INSTANCE]: "instanceId",
+        [vpc_1.RouterType.LOCAL_GATEWAY]: "localGatewayId",
+        [vpc_1.RouterType.NAT_GATEWAY]: "natGatewayId",
+        [vpc_1.RouterType.NETWORK_INTERFACE]: "networkInterfaceId",
+        [vpc_1.RouterType.TRANSIT_GATEWAY]: "transitGatewayId",
+        [vpc_1.RouterType.VPC_PEERING_CONNECTION]: "vpcPeeringConnectionId",
+        [vpc_1.RouterType.VPC_ENDPOINT]: "vpcEndpointId",
+    };
+    return lookupMap[routerType];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route.js","sourceRoot":"","sources":["../../../src/aws/compute/route.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/route.ts\n\nimport {\n  eip as tfEip,\n  egressOnlyInternetGateway as tfEgressOnlyInternetGateway,\n  internetGateway as tfInternetGateway,\n  natGateway as tfNatGateway,\n  vpcPeeringConnection as tfVpcPeeringConnection,\n  route as tfRoute,\n  routeTable as tfRouteTable,\n  vpnGatewayAttachment as tfVpnGatewayAttachment,\n  internetGatewayAttachment as tfInternetGatewayAttachment,\n  vpnGateway as tfVpnGateway,\n  vpnGatewayRoutePropagation as tfVpnGatewayRoutePropagation,\n} from \"@cdktf/provider-aws\";\nimport { Annotations } from \"cdktf\";\nimport { Construct, IDependable } from \"constructs\";\nimport { IRouteTable, RouterType, RouteTableOutputs } from \"./vpc\";\nimport {\n  GatewayVpcEndpoint,\n  IVpcEndpoint,\n  VpcEndpointOutputs,\n} from \"./vpc-endpoint\";\nimport { Duration } from \"../../duration\";\nimport {\n  AwsConstructBase,\n  AwsConstructProps,\n  IAwsConstruct,\n} from \"../aws-construct\";\n// TODO: Use TagManager and tag-aspect instead\nimport { Tags } from \"../aws-tags\";\n// import { Tags } from \"../tag-aspect\";\nimport { allRouteTableIds } from \"./ec2-util\";\nimport { NetworkUtils, CidrBlock } from \"./ec2-util-v2\";\nimport { ISubnetV2 } from \"./subnet-v2\";\nimport { IVpcV2, VPNGatewayV2Options } from \"./vpc-v2-base\";\n\n/**\n * Indicates whether the NAT gateway supports public or private connectivity.\n * The default is public connectivity.\n * See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-connectivitytype\n */\nexport enum NatConnectivityType {\n  /**\n   * Sets Connectivity type to PUBLIC\n   */\n  PUBLIC = \"public\",\n  /**\n   * Sets Connectivity type to PRIVATE\n   */\n  PRIVATE = \"private\",\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface RouteTargetOutputs {\n  /**\n   * The type of router used in the route.\n   *\n   * @attribute\n   */\n  readonly routerType: RouterType;\n  /**\n   * The ID of the route target.\n   *\n   * @attribute\n   */\n  readonly routerTargetId: string;\n}\n\n/**\n * Interface to define a routing target, such as an\n * egress-only internet gateway or VPC endpoint.\n */\nexport interface IRouteTarget extends IDependable {\n  /**\n   * The outputs of the route target.\n   */\n  readonly routeTargetOutputs: RouteTargetOutputs;\n\n  /**\n   * The type of router used in the route.\n   */\n  readonly routerType: RouterType;\n\n  /**\n   * The ID of the route target.\n   */\n  readonly routerTargetId: string;\n}\n\n/**\n * Properties to define an egress-only internet gateway.\n */\nexport interface EgressOnlyInternetGatewayProps {\n  /**\n   * The ID of the VPC for which to create the egress-only internet gateway.\n   */\n  readonly vpc: IVpcV2;\n\n  /**\n   * The resource name of the egress-only internet gateway.\n   *\n   * @default - provisioned without a resource name\n   */\n  readonly egressOnlyInternetGatewayName?: string;\n}\n\n/**\n * Properties to define an internet gateway.\n */\nexport interface InternetGatewayProps {\n  /**\n   * The ID of the VPC for which to create the internet gateway.\n   */\n  readonly vpc: IVpcV2;\n\n  /**\n   * The resource name of the internet gateway.\n   *\n   * @default - provisioned without a resource name\n   */\n  readonly internetGatewayName?: string;\n}\n\n/**\n * Properties to define a VPN gateway.\n */\nexport interface VPNGatewayV2Props\n  extends VPNGatewayV2Options,\n    AwsConstructProps {\n  /**\n   * The ID of the VPC for which to create the VPN gateway.\n   */\n  readonly vpc: IVpcV2;\n}\n\n/**\n * Options to define a NAT gateway.\n */\nexport interface NatGatewayOptions {\n  /**\n   * The subnet in which the NAT gateway is located.\n   */\n  readonly subnet: ISubnetV2;\n\n  /**\n   * AllocationID of Elastic IP address that's associated with the NAT gateway. This property is required for a public NAT\n   * gateway and cannot be specified with a private NAT gateway.\n   *\n   * @default - attr.allocationID of a new Elastic IP created by default\n   * //TODO: ADD L2 for elastic ip\n   */\n  readonly allocationId?: string;\n\n  /**\n   * Indicates whether the NAT gateway supports public or private connectivity.\n   *\n   * @default NatConnectivityType.Public\n   */\n  readonly connectivityType?: NatConnectivityType;\n\n  /**\n   * The maximum amount of time to wait before forcibly releasing the\n   * IP addresses if connections are still in progress.\n   *\n   * @default 350seconds\n   */\n  readonly maxDrainDuration?: Duration;\n\n  /**\n   * The private IPv4 address to assign to the NAT gateway.\n   *\n   * @default - If you don't provide an address, a private IPv4 address will be automatically assigned.\n   */\n  readonly privateIpAddress?: string;\n\n  /**\n   * Secondary EIP allocation IDs.\n   * @see https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating\n   *\n   * @default - no secondary allocation IDs attached to NATGW\n   *\n   */\n  readonly secondaryAllocationIds?: string[];\n\n  /**\n   * The number of secondary private IPv4 addresses you\n   * want to assign to the NAT gateway.\n   *\n   * `SecondaryPrivateIpAddressCount` and `SecondaryPrivateIpAddresses` cannot be\n   * set at the same time.\n   * @see https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating\n   *\n   * @default - no secondary allocation IDs associated with NATGW\n   */\n  readonly secondaryPrivateIpAddressCount?: number;\n\n  /**\n   * Secondary private IPv4 addresses.\n   *\n   * `SecondaryPrivateIpAddressCount` and `SecondaryPrivateIpAddresses` cannot be\n   * set at the same time.\n   * @see https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating\n   *\n   * @default - no secondary private IpAddresses associated with NATGW\n   */\n  readonly secondaryPrivateIpAddresses?: string[];\n\n  /**\n   * The resource name of the NAT gateway.\n   *\n   * @default - NATGW provisioned without any name\n   */\n  readonly natGatewayName?: string;\n}\n\n/**\n * Properties to define a NAT gateway.\n */\nexport interface NatGatewayProps extends NatGatewayOptions, AwsConstructProps {\n  /**\n   * The ID of the VPC in which the NAT gateway is located.\n   *\n   * @default - no elastic ip associated, required in case of public connectivity if `AllocationId` is not defined\n   */\n  readonly vpc?: IVpcV2;\n}\n\n/**\n * Options to define a VPC peering connection.\n */\nexport interface VPCPeeringConnectionOptions {\n  /**\n   * The VPC that is accepting the peering connection.\n   */\n  readonly acceptorVpc: IVpcV2;\n\n  // TODO: handle crossAccount TF Provider for vpc_peering_connection_accepter\n  // /**\n  //  * The role arn created in the acceptor account.\n  //  *\n  //  * @default - no peerRoleArn needed if not cross account connection\n  //  */\n  // readonly peerRoleArn?: string;\n\n  /**\n   * The resource name of the peering connection.\n   *\n   * @default - peering connection provisioned without any name\n   */\n  readonly vpcPeeringConnectionName?: string;\n}\n\n/**\n * Properties to define a VPC peering connection.\n */\nexport interface VPCPeeringConnectionProps extends VPCPeeringConnectionOptions {\n  /**\n   * The VPC that is requesting the peering connection.\n   */\n  readonly requestorVpc: IVpcV2;\n}\n\n/**\n * Name tag constant\n */\nconst NAME_TAG: string = \"Name\";\n\n/**\n * Creates an egress-only internet gateway\n * @resource aws_egress_only_internet_gateway\n */\nexport class EgressOnlyInternetGateway\n  extends AwsConstructBase\n  implements IRouteTarget\n{\n  public get routeTargetOutputs(): RouteTargetOutputs {\n    return {\n      routerType: this.routerType,\n      routerTargetId: this.routerTargetId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.routeTargetOutputs;\n  }\n  /**\n   * The type of router used in the route.\n   */\n  readonly routerType: RouterType;\n\n  /**\n   * The ID of the route target.\n   */\n  readonly routerTargetId: string;\n\n  /**\n   * The egress-only internet gateway CFN resource.\n   */\n  public readonly resource: tfEgressOnlyInternetGateway.EgressOnlyInternetGateway;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: EgressOnlyInternetGatewayProps,\n  ) {\n    super(scope, id);\n\n    if (props.egressOnlyInternetGatewayName) {\n      Tags.of(this).add(NAME_TAG, props.egressOnlyInternetGatewayName);\n    }\n    this.routerType = RouterType.EGRESS_ONLY_INTERNET_GATEWAY;\n\n    this.resource = new tfEgressOnlyInternetGateway.EgressOnlyInternetGateway(\n      this,\n      \"EIGW\",\n      {\n        vpcId: props.vpc.vpcId,\n      },\n    );\n    this.node.defaultChild = this.resource;\n\n    this.routerTargetId = this.resource.id;\n  }\n}\n\n/**\n * Creates an internet gateway\n * @resource AWS::EC2::InternetGateway\n */\nexport class InternetGateway extends AwsConstructBase implements IRouteTarget {\n  public get routeTargetOutputs(): RouteTargetOutputs {\n    return {\n      routerType: this.routerType,\n      routerTargetId: this.routerTargetId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.routeTargetOutputs;\n  }\n  /**\n   * The type of router used in the route.\n   */\n  readonly routerType: RouterType;\n\n  /**\n   * The ID of the route target.\n   */\n  readonly routerTargetId: string;\n\n  /**\n   * The ID of the VPC for which to create the internet gateway.\n   */\n  public readonly vpcId: string;\n\n  /**\n   * The internet gateway CFN resource.\n   */\n  public readonly resource: tfInternetGateway.InternetGateway;\n\n  constructor(scope: Construct, id: string, props: InternetGatewayProps) {\n    super(scope, id);\n\n    this.routerType = RouterType.GATEWAY;\n\n    this.resource = new tfInternetGateway.InternetGateway(this, \"IGW\", {});\n    this.node.defaultChild = this.resource;\n\n    this.routerTargetId = this.resource.id;\n    this.vpcId = props.vpc.vpcId;\n\n    if (props.internetGatewayName) {\n      Tags.of(this).add(NAME_TAG, props.internetGatewayName);\n    }\n\n    new tfInternetGatewayAttachment.InternetGatewayAttachment(\n      this,\n      \"GWAttachment\",\n      {\n        vpcId: this.vpcId,\n        internetGatewayId: this.routerTargetId,\n      },\n    );\n  }\n}\n\n/**\n * Creates a virtual private gateway\n * @resource AWS::EC2::VPNGateway\n */\nexport class VPNGatewayV2 extends AwsConstructBase implements IRouteTarget {\n  public get routeTargetOutputs(): RouteTargetOutputs {\n    return {\n      routerType: this.routerType,\n      routerTargetId: this.routerTargetId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.routeTargetOutputs;\n  }\n  /**\n   * The type of router used in the route.\n   */\n  readonly routerType: RouterType;\n\n  /**\n   * The ID of the route target.\n   */\n  readonly routerTargetId: string;\n\n  /**\n   * The ID of the VPC for which to create the VPN gateway.\n   */\n  public readonly vpcId: string;\n\n  /**\n   * The VPN gateway CFN resource.\n   */\n  public readonly resource: tfVpnGateway.VpnGateway;\n\n  /**\n   * The VPN Gateway Attachment\n   */\n  private readonly _attachment: tfVpnGatewayAttachment.VpnGatewayAttachment;\n\n  /**\n   * The VPN Gateway Route Propagation\n   */\n  private readonly _routePropagation: tfVpnGatewayRoutePropagation.VpnGatewayRoutePropagation[] =\n    [];\n\n  constructor(scope: Construct, id: string, props: VPNGatewayV2Props) {\n    super(scope, id, props);\n    const vpnGatewayName =\n      props.vpnGatewayName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    this.routerType = RouterType.GATEWAY;\n\n    this.resource = new tfVpnGateway.VpnGateway(this, \"IGW\", {\n      amazonSideAsn:\n        props.amazonSideAsn !== undefined\n          ? props.amazonSideAsn.toString()\n          : undefined,\n    });\n    this.node.defaultChild = this.resource;\n\n    this.routerTargetId = this.resource.id;\n\n    this.vpcId = props.vpc.vpcId;\n    this._attachment = new tfVpnGatewayAttachment.VpnGatewayAttachment(\n      this,\n      \"VPCVPNGW\",\n      {\n        vpcId: this.vpcId,\n        vpnGatewayId: this.resource.id,\n      },\n    );\n\n    if (props.vpnGatewayName) {\n      Tags.of(this).add(NAME_TAG, vpnGatewayName);\n    }\n\n    // Propagate routes on route tables associated with the right subnets\n    const vpnRoutePropagation = props.vpnRoutePropagation ?? [];\n    const subnets = vpnRoutePropagation\n      .map((s) => props.vpc.selectSubnets(s).subnets)\n      .flat();\n    const routeTableIds = allRouteTableIds(subnets);\n\n    if (routeTableIds.length === 0) {\n      // \"@aws-cdk:aws-ec2-elpha:enableVpnGatewayV2\",\n      Annotations.of(scope).addWarning(\n        `No subnets matching selection: '${JSON.stringify(vpnRoutePropagation)}'. Select other subnets to add routes to.`,\n      );\n    }\n\n    for (let i = 0; i < subnets.length; i++) {\n      const routePropagation =\n        new tfVpnGatewayRoutePropagation.VpnGatewayRoutePropagation(\n          this,\n          `RoutePropagation${i}`,\n          {\n            routeTableId: subnets[i].routeTable.routeTableId,\n            vpnGatewayId: this.routerTargetId,\n          },\n        );\n\n      // The AWS::EC2::VPNGatewayRoutePropagation resource cannot use the VPN gateway\n      // until it has successfully attached to the VPC.\n      // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-gatewayrouteprop.html\n      routePropagation.node.addDependency(this._attachment);\n      this._routePropagation.push(routePropagation);\n    }\n  }\n}\n\n/**\n * Creates a network address translation (NAT) gateway\n * @resource AWS::EC2::NatGateway\n */\nexport class NatGateway extends AwsConstructBase implements IRouteTarget {\n  public get routeTargetOutputs(): RouteTargetOutputs {\n    return {\n      routerType: this.routerType,\n      routerTargetId: this.routerTargetId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.routeTargetOutputs;\n  }\n  /**\n   * Id of the NatGateway\n   * @attribute\n   */\n  public readonly natGatewayId: string;\n\n  /**\n   * The type of router used in the route.\n   */\n  public readonly routerType: RouterType;\n\n  /**\n   * The ID of the route target.\n   */\n  public readonly routerTargetId: string;\n\n  /**\n   * Indicates whether the NAT gateway supports public or private connectivity.\n   *\n   * @default public\n   */\n  public readonly connectivityType?: NatConnectivityType;\n\n  /**\n   * The maximum amount of time to wait before forcibly releasing the\n   * IP addresses if connections are still in progress.\n   *\n   * @default '30 minutes'\n   */\n  public readonly maxDrainDuration?: Duration;\n\n  /**\n   * The NAT gateway CFN resource.\n   */\n  public readonly resource: tfNatGateway.NatGateway;\n\n  constructor(scope: Construct, id: string, props: NatGatewayProps) {\n    super(scope, id);\n\n    this.routerType = RouterType.NAT_GATEWAY;\n\n    this.connectivityType =\n      props.connectivityType || NatConnectivityType.PUBLIC;\n    this.maxDrainDuration = props.maxDrainDuration;\n\n    if (this.connectivityType === NatConnectivityType.PUBLIC) {\n      if (!props.vpc && !props.allocationId) {\n        throw new Error(\"Either provide vpc or allocationId\");\n      }\n    }\n\n    if (props.natGatewayName) {\n      Tags.of(this).add(NAME_TAG, props?.natGatewayName);\n    }\n\n    // If user does not provide EIP, generate one for them\n    var aId: string | undefined;\n    if (this.connectivityType === NatConnectivityType.PUBLIC) {\n      if (!props.allocationId) {\n        let eip = new tfEip.Eip(this, \"EIP\", {\n          domain: props.vpc?.vpcId,\n        });\n        aId = eip.allocationId;\n      } else {\n        aId = props.allocationId;\n      }\n    }\n\n    this.resource = new tfNatGateway.NatGateway(this, \"NATGateway\", {\n      subnetId: props.subnet.subnetId,\n      allocationId: aId,\n      privateIp: props.privateIpAddress,\n      // ...props,\n      connectivityType: props.connectivityType,\n      secondaryAllocationIds: props.secondaryAllocationIds,\n      secondaryPrivateIpAddressCount: props.secondaryPrivateIpAddressCount,\n      secondaryPrivateIpAddresses: props.secondaryPrivateIpAddresses,\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-maxdraindurationseconds\n      // https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/nat_gateway#timeouts\n      ...(this.maxDrainDuration\n        ? {\n            timeouts: {\n              delete: this.maxDrainDuration.toSeconds().toString(),\n            },\n          }\n        : {}),\n    });\n    this.natGatewayId = this.resource.id;\n\n    this.routerTargetId = this.resource.id;\n    this.node.defaultChild = this.resource;\n    this.node.addDependency(props.subnet.internetConnectivityEstablished);\n  }\n}\n\n/**\n * Creates a peering connection between two VPCs\n * @resource AWS::EC2::VPCPeeringConnection\n */\nexport class VPCPeeringConnection\n  extends AwsConstructBase\n  implements IRouteTarget\n{\n  public get routeTargetOutputs(): RouteTargetOutputs {\n    return {\n      routerType: this.routerType,\n      routerTargetId: this.routerTargetId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.routeTargetOutputs;\n  }\n  /**\n   * The type of router used in the route.\n   */\n  readonly routerType: RouterType;\n\n  /**\n   * The ID of the route target.\n   */\n  readonly routerTargetId: string;\n\n  /**\n   * The VPC peering connection CFN resource.\n   */\n  public readonly resource: tfVpcPeeringConnection.VpcPeeringConnection;\n\n  constructor(scope: Construct, id: string, props: VPCPeeringConnectionProps) {\n    super(scope, id);\n\n    this.routerType = RouterType.VPC_PEERING_CONNECTION;\n\n    // const isCrossAccount =\n    //   props.requestorVpc.ownerAccountId !== props.acceptorVpc.ownerAccountId;\n\n    // if (!isCrossAccount && props.peerRoleArn) {\n    //   throw new Error(\"peerRoleArn is not needed for same account peering\");\n    // }\n\n    // if (isCrossAccount && !props.peerRoleArn) {\n    //   throw new Error(\"Cross account VPC peering requires peerRoleArn\");\n    // }\n\n    const overlap = this.validateVpcCidrOverlap(\n      props.requestorVpc,\n      props.acceptorVpc,\n    );\n    if (overlap) {\n      throw new Error(\n        \"CIDR block should not overlap with each other for establishing a peering connection\",\n      );\n    }\n    if (props.vpcPeeringConnectionName) {\n      Tags.of(this).add(NAME_TAG, props.vpcPeeringConnectionName);\n    }\n\n    this.resource = new tfVpcPeeringConnection.VpcPeeringConnection(\n      this,\n      \"VPCPeeringConnection\",\n      {\n        vpcId: props.requestorVpc.vpcId,\n        peerVpcId: props.acceptorVpc.vpcId,\n        peerOwnerId: props.acceptorVpc.ownerAccountId,\n        peerRegion: props.acceptorVpc.region, // autoAccept must be false\n        // TODO: handle crossAccount TF Provider for vpc_peering_connection_accepter\n        // peerRoleArn: isCrossAccount ? props.peerRoleArn : undefined,\n      },\n    );\n    // TODO: Add aws_vpc_peering_connection_accepter to manage Accepter Side?\n\n    this.routerTargetId = this.resource.id;\n    this.node.defaultChild = this.resource;\n  }\n\n  /**\n   * Validates if the provided IPv4 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.\n   *\n   * @param requestorVpc The VPC of the requestor.\n   * @param acceptorVpc The VPC of the acceptor.\n   * @returns True if the IPv4 CIDR block overlaps with each other for two VPCs, false otherwise.\n   * @internal\n   */\n  private validateVpcCidrOverlap(\n    requestorVpc: IVpcV2,\n    acceptorVpc: IVpcV2,\n  ): boolean {\n    const requestorCidrs = [requestorVpc.ipv4CidrBlock];\n    const acceptorCidrs = [acceptorVpc.ipv4CidrBlock];\n\n    if (requestorVpc.secondaryCidrBlock) {\n      requestorCidrs.push(\n        ...requestorVpc.secondaryCidrBlock\n          .map((block) => block.cidrBlock)\n          .filter((cidr): cidr is string => cidr !== undefined),\n      );\n    }\n\n    if (acceptorVpc.secondaryCidrBlock) {\n      acceptorCidrs.push(\n        ...acceptorVpc.secondaryCidrBlock\n          .map((block) => block.cidrBlock)\n          .filter((cidr): cidr is string => cidr !== undefined),\n      );\n    }\n\n    for (const requestorCidr of requestorCidrs) {\n      const requestorRange = new CidrBlock(requestorCidr);\n      const requestorIpRange: [string, string] = [\n        requestorRange.minIp(),\n        requestorRange.maxIp(),\n      ];\n\n      for (const acceptorCidr of acceptorCidrs) {\n        const acceptorRange = new CidrBlock(acceptorCidr);\n        const acceptorIpRange: [string, string] = [\n          acceptorRange.minIp(),\n          acceptorRange.maxIp(),\n        ];\n\n        if (requestorRange.rangesOverlap(acceptorIpRange, requestorIpRange)) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n}\n\n/**\n * The type of endpoint or gateway being targeted by the route.\n */\nexport interface RouteTargetProps {\n  /**\n   * The gateway route target. This is used for targets such as\n   * egress-only internet gateway or VPC peering connection.\n   *\n   * @default - target is not set to a gateway, in this case an endpoint is needed.\n   */\n  readonly gateway?: IRouteTarget;\n\n  /**\n   * The endpoint route target. This is used for targets such as\n   * VPC endpoints.\n   *\n   * @default - target is not set to an endpoint, in this case a gateway is needed.\n   */\n  readonly endpoint?: IVpcEndpoint;\n}\n\n/**\n * The gateway or endpoint targeted by the route.\n */\nexport class RouteTargetType {\n  /**\n   * The gateway route target. This is used for targets such as\n   * egress-only internet gateway or VPC peering connection.\n   *\n   * @default - target is not set to a gateway, in this case an endpoint is needed.\n   */\n  readonly gateway?: IRouteTarget;\n\n  /**\n   * The endpoint route target. This is used for targets such as\n   * VPC endpoints.\n   *\n   * @default - target is not set to an endpoint, in this case a gateway is needed.\n   */\n  readonly endpoint?: IVpcEndpoint;\n\n  constructor(props: RouteTargetProps) {\n    if (\n      (props.gateway && props.endpoint) ||\n      (!props.gateway && !props.endpoint)\n    ) {\n      throw new Error(\n        \"Exactly one of `gateway` or `endpoint` must be specified.\",\n      );\n    } else {\n      this.gateway = props.gateway;\n      this.endpoint = props.endpoint;\n    }\n  }\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface RouteOutputs {\n  /**\n   * The ID of the route table for the route.\n   *\n   * @attribute\n   */\n  readonly routeTable: string;\n\n  /**\n   * The IPv4 or IPv6 CIDR block used for the destination match.\n   *\n   * Routing decisions are based on the most specific match.\n   *\n   * @attribute\n   */\n  readonly destination: string;\n\n  /**\n   * The gateway or endpoint targeted by the route.\n   *\n   * @attribute\n   */\n  readonly target: RouteTargetOutputs | VpcEndpointOutputs;\n}\n\n/**\n * Interface to define a route.\n */\nexport interface IRouteV2 extends IAwsConstruct {\n  /**\n   * The outputs of the route.\n   */\n  readonly routeOutputs: RouteOutputs;\n  /**\n   * The ID of the route table for the route.\n   * @attribute routeTable\n   */\n  readonly routeTable: IRouteTable;\n\n  /**\n   * The IPv4 or IPv6 CIDR block used for the destination match.\n   *\n   * Routing decisions are based on the most specific match.\n   * TODO: Look for strong IP type implementation here.\n   */\n  readonly destination: string;\n\n  /**\n   * The gateway or endpoint targeted by the route.\n   */\n  readonly target: RouteTargetType;\n}\n\n/**\n * Properties to define a route.\n */\nexport interface RouteProps {\n  /**\n   * The ID of the route table for the route.\n   *\n   * @attribute routeTable\n   */\n  readonly routeTable: IRouteTable;\n\n  /**\n   * The IPv4 or IPv6 CIDR block used for the destination match.\n   *\n   * Routing decisions are based on the most specific match.\n   */\n  readonly destination: string;\n\n  /**\n   * The gateway or endpoint targeted by the route.\n   */\n  readonly target: RouteTargetType;\n\n  /**\n   * The resource name of the route.\n   *\n   * @default - provisioned without a route name\n   */\n  readonly routeName?: string;\n}\n\n/**\n * Creates a new route with added functionality.\n * @resource AWS::EC2::Route\n */\nexport class Route extends AwsConstructBase implements IRouteV2 {\n  public get routeOutputs(): RouteOutputs {\n    return {\n      routeTable: this.routeTable.routeTableId,\n      destination: this.destination,\n      target: this.target.endpoint\n        ? this.target.endpoint.vpcEndpointOutputs\n        : this.target.gateway!.routeTargetOutputs,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.routeOutputs;\n  }\n  /**\n   * The IPv4 or IPv6 CIDR block used for the destination match.\n   *\n   * Routing decisions are based on the most specific match.\n   */\n  public readonly destination: string;\n\n  /**\n   * The gateway or endpoint targeted by the route.\n   */\n  public readonly target: RouteTargetType;\n\n  /**\n   * The route table for the route.\n   * @attribute routeTable\n   */\n  public readonly routeTable: IRouteTable;\n\n  /**\n   * The type of router the route is targeting\n   */\n  public readonly targetRouterType: RouterType;\n\n  /**\n   * The route CFN resource.\n   */\n  public readonly resource?: tfRoute.Route;\n\n  /**\n   * Destination cidr block for ipv6\n   */\n  private destinationIpv6Cidr?: string;\n\n  /**\n   * Destination cidr block for ipv4\n   */\n  private destinationIpv4Cidr?: string;\n\n  constructor(scope: Construct, id: string, props: RouteProps) {\n    super(scope, id);\n\n    this.target = props.target;\n    this.routeTable = props.routeTable;\n    this.destination = props.destination;\n    const isDestinationIpv4 = NetworkUtils.validIp(props.destination);\n    if (!isDestinationIpv4) {\n      //TODO Validate for IPv6 CIDR range\n      this.destinationIpv6Cidr = props.destination;\n    } else {\n      this.destinationIpv4Cidr = props.destination;\n    }\n\n    if (\n      this.target.gateway?.routerType ===\n        RouterType.EGRESS_ONLY_INTERNET_GATEWAY &&\n      isDestinationIpv4\n    ) {\n      throw new Error(\n        \"Egress only internet gateway does not support IPv4 routing\",\n      );\n    }\n    this.targetRouterType = this.target.gateway\n      ? this.target.gateway.routerType\n      : RouterType.VPC_ENDPOINT;\n    // Gateway generates route automatically via its RouteTable, thus we don't need to generate the resource for it\n    if (!(this.target.endpoint instanceof GatewayVpcEndpoint)) {\n      this.resource = new tfRoute.Route(this, \"Route\", {\n        routeTableId: this.routeTable.routeTableId,\n        destinationCidrBlock: this.destinationIpv4Cidr,\n        destinationIpv6CidrBlock: this.destinationIpv6Cidr,\n        [routerTypeToPropName(this.targetRouterType)]: this.target.gateway\n          ? this.target.gateway.routerTargetId\n          : this.target.endpoint\n            ? this.target.endpoint.vpcEndpointId\n            : null,\n      });\n    }\n    this.node.defaultChild = this.resource;\n\n    //Create a route only after target gateway or endpoint is created\n    if (this.target.gateway) {\n      this.node.addDependency(this.target.gateway);\n    }\n    if (this.target.endpoint) {\n      this.node.addDependency(this.target.endpoint);\n    }\n  }\n}\n\n/**\n * Properties to define a route table.\n */\nexport interface RouteTableProps {\n  /**\n   * The ID of the VPC.\n   */\n  readonly vpc: IVpcV2;\n\n  /**\n   * The resource name of the route table.\n   *\n   * @default - provisioned without a route table name\n   */\n  readonly routeTableName?: string;\n}\n\n/**\n * Creates a route table for the specified VPC\n * @resource aws_route_table\n */\nexport class RouteTable extends AwsConstructBase implements IRouteTable {\n  public get routeTableOutputs(): RouteTableOutputs {\n    return {\n      routeTableId: this.routeTableId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.routeTableOutputs;\n  }\n  /**\n   * The ID of the route table.\n   */\n  public readonly routeTableId: string;\n\n  /**\n   * The route table CFN resource.\n   */\n  public readonly resource: tfRouteTable.RouteTable;\n\n  constructor(scope: Construct, id: string, props: RouteTableProps) {\n    super(scope, id);\n\n    this.resource = new tfRouteTable.RouteTable(this, \"RouteTable\", {\n      vpcId: props.vpc.vpcId,\n    });\n    if (props.routeTableName) {\n      Tags.of(this).add(NAME_TAG, props.routeTableName);\n    }\n    this.node.defaultChild = this.resource;\n\n    this.routeTableId = this.resource.id;\n  }\n\n  /**\n   * Adds a new custom route to the route table.\n   *\n   * @param destination The IPv4 or IPv6 CIDR block used for the destination match.\n   * @param target The gateway or endpoint targeted by the route.\n   * @param routeName The resource name of the route.\n   */\n  public addRoute(\n    id: string,\n    destination: string,\n    target: RouteTargetType,\n    routeName?: string,\n  ) {\n    new Route(this, id, {\n      routeTable: this,\n      destination: destination,\n      target: target,\n      routeName: routeName,\n    });\n  }\n}\n\n/**\n * inverse of\n * https://github.com/hashicorp/terraform-provider-aws/blob/v5.87.0/internal/service/ec2/vpc_route.go#L219-L239\n */\nfunction routerTypeToPropName(routerType: RouterType) {\n  const lookupMap: Record<RouterType, keyof tfRoute.RouteConfig> = {\n    [RouterType.CARRIER_GATEWAY]: \"carrierGatewayId\",\n    [RouterType.EGRESS_ONLY_INTERNET_GATEWAY]: \"egressOnlyGatewayId\",\n    [RouterType.GATEWAY]: \"gatewayId\",\n    // terraform-provider-aws is missing switch case for InstanceId\n    // https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateRoute.html\n    // [RouterType.INSTANCE]: \"instanceId\",\n    [RouterType.LOCAL_GATEWAY]: \"localGatewayId\",\n    [RouterType.NAT_GATEWAY]: \"natGatewayId\",\n    [RouterType.NETWORK_INTERFACE]: \"networkInterfaceId\",\n    [RouterType.TRANSIT_GATEWAY]: \"transitGatewayId\",\n    [RouterType.VPC_PEERING_CONNECTION]: \"vpcPeeringConnectionId\",\n    [RouterType.VPC_ENDPOINT]: \"vpcEndpointId\",\n  };\n  return lookupMap[routerType];\n}\n"]}