@microsoft/terraform-cdk-constructs 1.0.0 → 1.2.0

package/lib/azure-subnet/test/subnet.spec.js

@@ -0,0 +1,396 @@
+"use strict";
+/**
+ * Comprehensive tests for the Subnet implementation
+ *
+ * This test suite validates the Subnet class using the AzapiResource framework.
+ * Tests cover automatic version resolution, explicit version pinning, schema validation,
+ * property transformation, and resource creation including parent-child relationship.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const subnet_1 = require("../lib/subnet");
+describe("Subnet - Implementation", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create subnet with automatic latest version resolution", () => {
+            const props = {
+                name: "test-subnet",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            };
+            const subnet = new subnet_1.Subnet(stack, "TestSubnet", props);
+            expect(subnet).toBeInstanceOf(subnet_1.Subnet);
+            expect(subnet.props).toBe(props);
+            expect(subnet.name).toBe("test-subnet");
+        });
+        it("should create subnet with explicit version pinning", () => {
+            const props = {
+                name: "test-subnet-pinned",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+                apiVersion: "2024-07-01",
+            };
+            const subnet = new subnet_1.Subnet(stack, "TestSubnet", props);
+            expect(subnet.resolvedApiVersion).toBe("2024-07-01");
+        });
+        it("should create subnet with all optional properties", () => {
+            const props = {
+                name: "test-subnet-full",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.2.0/24",
+                networkSecurityGroup: {
+                    id: "/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/networkSecurityGroups/test-nsg",
+                },
+                routeTable: {
+                    id: "/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/routeTables/test-rt",
+                },
+                serviceEndpoints: [
+                    {
+                        service: "Microsoft.Storage",
+                        locations: ["eastus"],
+                    },
+                ],
+                delegations: [
+                    {
+                        name: "test-delegation",
+                        serviceName: "Microsoft.Sql/managedInstances",
+                    },
+                ],
+                privateEndpointNetworkPolicies: "Enabled",
+                privateLinkServiceNetworkPolicies: "Disabled",
+                ignoreChanges: ["networkSecurityGroup"],
+            };
+            const subnet = new subnet_1.Subnet(stack, "TestSubnet", props);
+            expect(subnet.props.addressPrefix).toEqual(props.addressPrefix);
+            expect(subnet.props.networkSecurityGroup).toEqual(props.networkSecurityGroup);
+            expect(subnet.props.serviceEndpoints).toEqual(props.serviceEndpoints);
+        });
+        it("should use default name when name is not provided", () => {
+            const props = {
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            };
+            const subnet = new subnet_1.Subnet(stack, "TestSubnet", props);
+            expect(subnet.name).toBe("TestSubnet");
+        });
+    });
+    describe("Resource Type and API Versions", () => {
+        it("should have correct resource type", () => {
+            const subnet = new subnet_1.Subnet(stack, "TestSubnet", {
+                name: "test-subnet",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            expect(subnet).toBeInstanceOf(subnet_1.Subnet);
+        });
+        it("should support all registered API versions", () => {
+            const versions = ["2024-07-01", "2024-10-01"];
+            versions.forEach((version) => {
+                const subnet = new subnet_1.Subnet(stack, `Subnet-${version.replace(/-/g, "")}`, {
+                    name: `subnet-${version}`,
+                    virtualNetworkName: "test-vnet",
+                    resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                    addressPrefix: "10.0.1.0/24",
+                    apiVersion: version,
+                });
+                expect(subnet.resolvedApiVersion).toBe(version);
+            });
+        });
+        it("should use latest version as default", () => {
+            const subnet = new subnet_1.Subnet(stack, "TestSubnet", {
+                name: "test-subnet",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            expect(subnet.resolvedApiVersion).toBe("2024-10-01");
+        });
+    });
+    describe("Address Prefix Configuration", () => {
+        it("should create subnet with valid CIDR notation", () => {
+            const subnet = new subnet_1.Subnet(stack, "CIDRSubnet", {
+                name: "subnet-cidr",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.5.0/24",
+            });
+            expect(subnet.props.addressPrefix).toBe("10.0.5.0/24");
+        });
+        it("should handle different subnet sizes", () => {
+            const subnet = new subnet_1.Subnet(stack, "LargeSubnet", {
+                name: "subnet-large",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.0.0/16",
+            });
+            expect(subnet.props.addressPrefix).toBe("10.0.0.0/16");
+        });
+    });
+    describe("Parent Virtual Network Relationship", () => {
+        it("should construct correct virtual network ID", () => {
+            const subnet = new subnet_1.Subnet(stack, "ParentTest", {
+                name: "test-subnet",
+                virtualNetworkName: "my-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            expect(subnet.virtualNetworkId).toBe("/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/virtualNetworks/my-vnet");
+        });
+        it("should require virtualNetworkName", () => {
+            const props = {
+                name: "test-subnet",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            };
+            const subnet = new subnet_1.Subnet(stack, "TestSubnet", props);
+            expect(subnet.props.virtualNetworkName).toBe("test-vnet");
+        });
+    });
+    describe("Network Security Group Association", () => {
+        it("should create subnet with NSG reference", () => {
+            const subnet = new subnet_1.Subnet(stack, "NSGSubnet", {
+                name: "subnet-with-nsg",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+                networkSecurityGroup: {
+                    id: "/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/networkSecurityGroups/my-nsg",
+                },
+            });
+            expect(subnet.props.networkSecurityGroup).toBeDefined();
+            expect(subnet.props.networkSecurityGroup?.id).toContain("networkSecurityGroups/my-nsg");
+        });
+        it("should create subnet without NSG", () => {
+            const subnet = new subnet_1.Subnet(stack, "NoNSG", {
+                name: "subnet-no-nsg",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            expect(subnet.props.networkSecurityGroup).toBeUndefined();
+        });
+    });
+    describe("Service Endpoints Configuration", () => {
+        it("should create subnet with service endpoints", () => {
+            const subnet = new subnet_1.Subnet(stack, "ServiceEndpoints", {
+                name: "subnet-endpoints",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+                serviceEndpoints: [
+                    {
+                        service: "Microsoft.Storage",
+                        locations: ["eastus"],
+                    },
+                    {
+                        service: "Microsoft.Sql",
+                        locations: ["eastus", "westus"],
+                    },
+                ],
+            });
+            expect(subnet.props.serviceEndpoints).toHaveLength(2);
+            expect(subnet.props.serviceEndpoints[0].service).toBe("Microsoft.Storage");
+            expect(subnet.props.serviceEndpoints[1].service).toBe("Microsoft.Sql");
+        });
+        it("should create subnet without service endpoints", () => {
+            const subnet = new subnet_1.Subnet(stack, "NoEndpoints", {
+                name: "subnet-no-endpoints",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            expect(subnet.props.serviceEndpoints).toBeUndefined();
+        });
+    });
+    describe("Subnet Delegations", () => {
+        it("should create subnet with delegation", () => {
+            const subnet = new subnet_1.Subnet(stack, "DelegatedSubnet", {
+                name: "subnet-delegated",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+                delegations: [
+                    {
+                        name: "sql-delegation",
+                        serviceName: "Microsoft.Sql/managedInstances",
+                    },
+                ],
+            });
+            expect(subnet.props.delegations).toHaveLength(1);
+            expect(subnet.props.delegations[0].serviceName).toBe("Microsoft.Sql/managedInstances");
+        });
+        it("should create subnet without delegation", () => {
+            const subnet = new subnet_1.Subnet(stack, "NoDelegation", {
+                name: "subnet-no-delegation",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            expect(subnet.props.delegations).toBeUndefined();
+        });
+    });
+    describe("Private Endpoint Policies", () => {
+        it("should set custom private endpoint policies", () => {
+            const subnet = new subnet_1.Subnet(stack, "PrivatePolicies", {
+                name: "subnet-policies",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+                privateEndpointNetworkPolicies: "Enabled",
+                privateLinkServiceNetworkPolicies: "Disabled",
+            });
+            expect(subnet.props.privateEndpointNetworkPolicies).toBe("Enabled");
+            expect(subnet.props.privateLinkServiceNetworkPolicies).toBe("Disabled");
+        });
+        it("should use default policies when not specified", () => {
+            const subnet = new subnet_1.Subnet(stack, "DefaultPolicies", {
+                name: "subnet-default-policies",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            expect(subnet.props.privateEndpointNetworkPolicies).toBeUndefined();
+            expect(subnet.props.privateLinkServiceNetworkPolicies).toBeUndefined();
+        });
+    });
+    describe("Terraform Outputs", () => {
+        it("should create Terraform outputs", () => {
+            const subnet = new subnet_1.Subnet(stack, "OutputTest", {
+                name: "subnet-outputs",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            expect(subnet.idOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(subnet.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(subnet.addressPrefixOutput).toBeInstanceOf(cdktf.TerraformOutput);
+        });
+        it("should have correct id format", () => {
+            const subnet = new subnet_1.Subnet(stack, "IdFormat", {
+                name: "subnet-id",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            expect(subnet.id).toMatch(/^\$\{.*\.id\}$/);
+            expect(subnet.resourceId).toBe(subnet.id);
+        });
+    });
+    describe("Version Compatibility", () => {
+        it("should work with all supported API versions", () => {
+            const versions = ["2024-07-01", "2024-10-01"];
+            versions.forEach((version) => {
+                const subnet = new subnet_1.Subnet(stack, `Subnet-${version.replace(/-/g, "")}`, {
+                    name: `subnet-${version}`,
+                    virtualNetworkName: "test-vnet",
+                    resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                    addressPrefix: "10.0.1.0/24",
+                    apiVersion: version,
+                });
+                expect(subnet.resolvedApiVersion).toBe(version);
+            });
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            const subnet = new subnet_1.Subnet(stack, "IgnoreChanges", {
+                name: "subnet-ignore",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+                ignoreChanges: ["networkSecurityGroup", "routeTable"],
+            });
+            expect(subnet).toBeInstanceOf(subnet_1.Subnet);
+            expect(subnet.props.ignoreChanges).toEqual([
+                "networkSecurityGroup",
+                "routeTable",
+            ]);
+        });
+        it("should handle empty ignore changes array", () => {
+            const subnet = new subnet_1.Subnet(stack, "EmptyIgnore", {
+                name: "subnet-empty-ignore",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+                ignoreChanges: [],
+            });
+            expect(subnet).toBeInstanceOf(subnet_1.Subnet);
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new subnet_1.Subnet(stack, "SynthTest", {
+                name: "subnet-synth",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should handle multiple subnets in the same stack", () => {
+            const subnet1 = new subnet_1.Subnet(stack, "Subnet1", {
+                name: "subnet-1",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+            });
+            const subnet2 = new subnet_1.Subnet(stack, "Subnet2", {
+                name: "subnet-2",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.2.0/24",
+                apiVersion: "2024-10-01",
+            });
+            expect(subnet1.resolvedApiVersion).toBe("2024-10-01");
+            expect(subnet2.resolvedApiVersion).toBe("2024-10-01");
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+    describe("Route Table Association", () => {
+        it("should create subnet with route table", () => {
+            const subnet = new subnet_1.Subnet(stack, "RouteTableSubnet", {
+                name: "subnet-with-rt",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+                routeTable: {
+                    id: "/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/routeTables/my-rt",
+                },
+            });
+            expect(subnet.props.routeTable).toBeDefined();
+            expect(subnet.props.routeTable?.id).toContain("routeTables/my-rt");
+        });
+    });
+    describe("NAT Gateway Association", () => {
+        it("should create subnet with NAT gateway", () => {
+            const subnet = new subnet_1.Subnet(stack, "NATSubnet", {
+                name: "subnet-with-nat",
+                virtualNetworkName: "test-vnet",
+                resourceGroupId: "/subscriptions/test-sub/resourceGroups/test-rg",
+                addressPrefix: "10.0.1.0/24",
+                natGateway: {
+                    id: "/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/natGateways/my-nat",
+                },
+            });
+            expect(subnet.props.natGateway).toBeDefined();
+            expect(subnet.props.natGateway?.id).toContain("natGateways/my-nat");
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subnet.spec.js","sourceRoot":"","sources":["../../../src/azure-subnet/test/subnet.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for the Subnet implementation\n *\n * This test suite validates the Subnet class using the AzapiResource framework.\n * Tests cover automatic version resolution, explicit version pinning, schema validation,\n * property transformation, and resource creation including parent-child relationship.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { Subnet, SubnetProps } from \"../lib/subnet\";\n\ndescribe(\"Subnet - Implementation\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create subnet with automatic latest version resolution\", () => {\n      const props: SubnetProps = {\n        name: \"test-subnet\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      };\n\n      const subnet = new Subnet(stack, \"TestSubnet\", props);\n\n      expect(subnet).toBeInstanceOf(Subnet);\n      expect(subnet.props).toBe(props);\n      expect(subnet.name).toBe(\"test-subnet\");\n    });\n\n    it(\"should create subnet with explicit version pinning\", () => {\n      const props: SubnetProps = {\n        name: \"test-subnet-pinned\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n        apiVersion: \"2024-07-01\",\n      };\n\n      const subnet = new Subnet(stack, \"TestSubnet\", props);\n\n      expect(subnet.resolvedApiVersion).toBe(\"2024-07-01\");\n    });\n\n    it(\"should create subnet with all optional properties\", () => {\n      const props: SubnetProps = {\n        name: \"test-subnet-full\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.2.0/24\",\n        networkSecurityGroup: {\n          id: \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/networkSecurityGroups/test-nsg\",\n        },\n        routeTable: {\n          id: \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/routeTables/test-rt\",\n        },\n        serviceEndpoints: [\n          {\n            service: \"Microsoft.Storage\",\n            locations: [\"eastus\"],\n          },\n        ],\n        delegations: [\n          {\n            name: \"test-delegation\",\n            serviceName: \"Microsoft.Sql/managedInstances\",\n          },\n        ],\n        privateEndpointNetworkPolicies: \"Enabled\",\n        privateLinkServiceNetworkPolicies: \"Disabled\",\n        ignoreChanges: [\"networkSecurityGroup\"],\n      };\n\n      const subnet = new Subnet(stack, \"TestSubnet\", props);\n\n      expect(subnet.props.addressPrefix).toEqual(props.addressPrefix);\n      expect(subnet.props.networkSecurityGroup).toEqual(\n        props.networkSecurityGroup,\n      );\n      expect(subnet.props.serviceEndpoints).toEqual(props.serviceEndpoints);\n    });\n\n    it(\"should use default name when name is not provided\", () => {\n      const props: SubnetProps = {\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      };\n\n      const subnet = new Subnet(stack, \"TestSubnet\", props);\n\n      expect(subnet.name).toBe(\"TestSubnet\");\n    });\n  });\n\n  describe(\"Resource Type and API Versions\", () => {\n    it(\"should have correct resource type\", () => {\n      const subnet = new Subnet(stack, \"TestSubnet\", {\n        name: \"test-subnet\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      expect(subnet).toBeInstanceOf(Subnet);\n    });\n\n    it(\"should support all registered API versions\", () => {\n      const versions = [\"2024-07-01\", \"2024-10-01\"];\n\n      versions.forEach((version) => {\n        const subnet = new Subnet(\n          stack,\n          `Subnet-${version.replace(/-/g, \"\")}`,\n          {\n            name: `subnet-${version}`,\n            virtualNetworkName: \"test-vnet\",\n            resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n            addressPrefix: \"10.0.1.0/24\",\n            apiVersion: version,\n          },\n        );\n\n        expect(subnet.resolvedApiVersion).toBe(version);\n      });\n    });\n\n    it(\"should use latest version as default\", () => {\n      const subnet = new Subnet(stack, \"TestSubnet\", {\n        name: \"test-subnet\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      expect(subnet.resolvedApiVersion).toBe(\"2024-10-01\");\n    });\n  });\n\n  describe(\"Address Prefix Configuration\", () => {\n    it(\"should create subnet with valid CIDR notation\", () => {\n      const subnet = new Subnet(stack, \"CIDRSubnet\", {\n        name: \"subnet-cidr\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.5.0/24\",\n      });\n\n      expect(subnet.props.addressPrefix).toBe(\"10.0.5.0/24\");\n    });\n\n    it(\"should handle different subnet sizes\", () => {\n      const subnet = new Subnet(stack, \"LargeSubnet\", {\n        name: \"subnet-large\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.0.0/16\",\n      });\n\n      expect(subnet.props.addressPrefix).toBe(\"10.0.0.0/16\");\n    });\n  });\n\n  describe(\"Parent Virtual Network Relationship\", () => {\n    it(\"should construct correct virtual network ID\", () => {\n      const subnet = new Subnet(stack, \"ParentTest\", {\n        name: \"test-subnet\",\n        virtualNetworkName: \"my-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      expect(subnet.virtualNetworkId).toBe(\n        \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/virtualNetworks/my-vnet\",\n      );\n    });\n\n    it(\"should require virtualNetworkName\", () => {\n      const props: SubnetProps = {\n        name: \"test-subnet\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      };\n\n      const subnet = new Subnet(stack, \"TestSubnet\", props);\n\n      expect(subnet.props.virtualNetworkName).toBe(\"test-vnet\");\n    });\n  });\n\n  describe(\"Network Security Group Association\", () => {\n    it(\"should create subnet with NSG reference\", () => {\n      const subnet = new Subnet(stack, \"NSGSubnet\", {\n        name: \"subnet-with-nsg\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n        networkSecurityGroup: {\n          id: \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/networkSecurityGroups/my-nsg\",\n        },\n      });\n\n      expect(subnet.props.networkSecurityGroup).toBeDefined();\n      expect(subnet.props.networkSecurityGroup?.id).toContain(\n        \"networkSecurityGroups/my-nsg\",\n      );\n    });\n\n    it(\"should create subnet without NSG\", () => {\n      const subnet = new Subnet(stack, \"NoNSG\", {\n        name: \"subnet-no-nsg\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      expect(subnet.props.networkSecurityGroup).toBeUndefined();\n    });\n  });\n\n  describe(\"Service Endpoints Configuration\", () => {\n    it(\"should create subnet with service endpoints\", () => {\n      const subnet = new Subnet(stack, \"ServiceEndpoints\", {\n        name: \"subnet-endpoints\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n        serviceEndpoints: [\n          {\n            service: \"Microsoft.Storage\",\n            locations: [\"eastus\"],\n          },\n          {\n            service: \"Microsoft.Sql\",\n            locations: [\"eastus\", \"westus\"],\n          },\n        ],\n      });\n\n      expect(subnet.props.serviceEndpoints).toHaveLength(2);\n      expect(subnet.props.serviceEndpoints![0].service).toBe(\n        \"Microsoft.Storage\",\n      );\n      expect(subnet.props.serviceEndpoints![1].service).toBe(\"Microsoft.Sql\");\n    });\n\n    it(\"should create subnet without service endpoints\", () => {\n      const subnet = new Subnet(stack, \"NoEndpoints\", {\n        name: \"subnet-no-endpoints\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      expect(subnet.props.serviceEndpoints).toBeUndefined();\n    });\n  });\n\n  describe(\"Subnet Delegations\", () => {\n    it(\"should create subnet with delegation\", () => {\n      const subnet = new Subnet(stack, \"DelegatedSubnet\", {\n        name: \"subnet-delegated\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n        delegations: [\n          {\n            name: \"sql-delegation\",\n            serviceName: \"Microsoft.Sql/managedInstances\",\n          },\n        ],\n      });\n\n      expect(subnet.props.delegations).toHaveLength(1);\n      expect(subnet.props.delegations![0].serviceName).toBe(\n        \"Microsoft.Sql/managedInstances\",\n      );\n    });\n\n    it(\"should create subnet without delegation\", () => {\n      const subnet = new Subnet(stack, \"NoDelegation\", {\n        name: \"subnet-no-delegation\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      expect(subnet.props.delegations).toBeUndefined();\n    });\n  });\n\n  describe(\"Private Endpoint Policies\", () => {\n    it(\"should set custom private endpoint policies\", () => {\n      const subnet = new Subnet(stack, \"PrivatePolicies\", {\n        name: \"subnet-policies\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n        privateEndpointNetworkPolicies: \"Enabled\",\n        privateLinkServiceNetworkPolicies: \"Disabled\",\n      });\n\n      expect(subnet.props.privateEndpointNetworkPolicies).toBe(\"Enabled\");\n      expect(subnet.props.privateLinkServiceNetworkPolicies).toBe(\"Disabled\");\n    });\n\n    it(\"should use default policies when not specified\", () => {\n      const subnet = new Subnet(stack, \"DefaultPolicies\", {\n        name: \"subnet-default-policies\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      expect(subnet.props.privateEndpointNetworkPolicies).toBeUndefined();\n      expect(subnet.props.privateLinkServiceNetworkPolicies).toBeUndefined();\n    });\n  });\n\n  describe(\"Terraform Outputs\", () => {\n    it(\"should create Terraform outputs\", () => {\n      const subnet = new Subnet(stack, \"OutputTest\", {\n        name: \"subnet-outputs\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      expect(subnet.idOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(subnet.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(subnet.addressPrefixOutput).toBeInstanceOf(cdktf.TerraformOutput);\n    });\n\n    it(\"should have correct id format\", () => {\n      const subnet = new Subnet(stack, \"IdFormat\", {\n        name: \"subnet-id\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      expect(subnet.id).toMatch(/^\\$\\{.*\\.id\\}$/);\n      expect(subnet.resourceId).toBe(subnet.id);\n    });\n  });\n\n  describe(\"Version Compatibility\", () => {\n    it(\"should work with all supported API versions\", () => {\n      const versions = [\"2024-07-01\", \"2024-10-01\"];\n\n      versions.forEach((version) => {\n        const subnet = new Subnet(\n          stack,\n          `Subnet-${version.replace(/-/g, \"\")}`,\n          {\n            name: `subnet-${version}`,\n            virtualNetworkName: \"test-vnet\",\n            resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n            addressPrefix: \"10.0.1.0/24\",\n            apiVersion: version,\n          },\n        );\n\n        expect(subnet.resolvedApiVersion).toBe(version);\n      });\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      const subnet = new Subnet(stack, \"IgnoreChanges\", {\n        name: \"subnet-ignore\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n        ignoreChanges: [\"networkSecurityGroup\", \"routeTable\"],\n      });\n\n      expect(subnet).toBeInstanceOf(Subnet);\n      expect(subnet.props.ignoreChanges).toEqual([\n        \"networkSecurityGroup\",\n        \"routeTable\",\n      ]);\n    });\n\n    it(\"should handle empty ignore changes array\", () => {\n      const subnet = new Subnet(stack, \"EmptyIgnore\", {\n        name: \"subnet-empty-ignore\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n        ignoreChanges: [],\n      });\n\n      expect(subnet).toBeInstanceOf(Subnet);\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new Subnet(stack, \"SynthTest\", {\n        name: \"subnet-synth\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n\n      const stackConfig = JSON.parse(synthesized);\n      expect(stackConfig.resource).toBeDefined();\n    });\n\n    it(\"should handle multiple subnets in the same stack\", () => {\n      const subnet1 = new Subnet(stack, \"Subnet1\", {\n        name: \"subnet-1\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n      });\n\n      const subnet2 = new Subnet(stack, \"Subnet2\", {\n        name: \"subnet-2\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.2.0/24\",\n        apiVersion: \"2024-10-01\",\n      });\n\n      expect(subnet1.resolvedApiVersion).toBe(\"2024-10-01\");\n      expect(subnet2.resolvedApiVersion).toBe(\"2024-10-01\");\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n\n  describe(\"Route Table Association\", () => {\n    it(\"should create subnet with route table\", () => {\n      const subnet = new Subnet(stack, \"RouteTableSubnet\", {\n        name: \"subnet-with-rt\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n        routeTable: {\n          id: \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/routeTables/my-rt\",\n        },\n      });\n\n      expect(subnet.props.routeTable).toBeDefined();\n      expect(subnet.props.routeTable?.id).toContain(\"routeTables/my-rt\");\n    });\n  });\n\n  describe(\"NAT Gateway Association\", () => {\n    it(\"should create subnet with NAT gateway\", () => {\n      const subnet = new Subnet(stack, \"NATSubnet\", {\n        name: \"subnet-with-nat\",\n        virtualNetworkName: \"test-vnet\",\n        resourceGroupId: \"/subscriptions/test-sub/resourceGroups/test-rg\",\n        addressPrefix: \"10.0.1.0/24\",\n        natGateway: {\n          id: \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Network/natGateways/my-nat\",\n        },\n      });\n\n      expect(subnet.props.natGateway).toBeDefined();\n      expect(subnet.props.natGateway?.id).toContain(\"natGateways/my-nat\");\n    });\n  });\n});\n"]}

package/lib/azure-virtualmachine/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Azure Virtual Machine Constructs
+ *
+ * This module provides a unified, version-aware implementation for Azure Virtual Machines
+ * using the VersionedAzapiResource framework.
+ */
+export * from "./lib";

package/lib/azure-virtualmachine/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Azure Virtual Machine Constructs
+ *
+ * This module provides a unified, version-aware implementation for Azure Virtual Machines
+ * using the VersionedAzapiResource framework.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtdmlydHVhbG1hY2hpbmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7OztHQUtHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsd0NBQXNCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBBenVyZSBWaXJ0dWFsIE1hY2hpbmUgQ29uc3RydWN0c1xuICpcbiAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIGEgdW5pZmllZCwgdmVyc2lvbi1hd2FyZSBpbXBsZW1lbnRhdGlvbiBmb3IgQXp1cmUgVmlydHVhbCBNYWNoaW5lc1xuICogdXNpbmcgdGhlIFZlcnNpb25lZEF6YXBpUmVzb3VyY2UgZnJhbWV3b3JrLlxuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL2xpYlwiO1xuIl19

package/lib/azure-virtualmachine/lib/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Azure Virtual Machine Constructs using VersionedAzapiResource Framework
+ */
+export * from "./virtual-machine";
+export * from "./virtual-machine-schemas";
+export { VirtualMachine } from "./virtual-machine";
+export type { VirtualMachineProps } from "./virtual-machine";
+export type { VirtualMachineBody } from "./virtual-machine";
+export type { VirtualMachineBodyProperties } from "./virtual-machine";
+export { VIRTUAL_MACHINE_TYPE, ALL_VIRTUAL_MACHINE_VERSIONS, VIRTUAL_MACHINE_SCHEMA_2024_07_01, VIRTUAL_MACHINE_SCHEMA_2024_11_01, VIRTUAL_MACHINE_SCHEMA_2025_04_01, VIRTUAL_MACHINE_VERSION_2024_07_01, VIRTUAL_MACHINE_VERSION_2024_11_01, VIRTUAL_MACHINE_VERSION_2025_04_01, } from "./virtual-machine-schemas";
+export type { VirtualMachineHardwareProfile, VirtualMachineImageReference, VirtualMachineOSDisk, VirtualMachineDataDisk, VirtualMachineManagedDiskParameters, VirtualMachineDiskEncryptionSetParameters, VirtualMachineStorageProfile, VirtualMachineNetworkInterfaceReference, VirtualMachineNetworkProfile, VirtualMachineSshPublicKey, VirtualMachineSshConfiguration, VirtualMachineLinuxConfiguration, VirtualMachineLinuxPatchSettings, VirtualMachineWindowsConfiguration, VirtualMachineWindowsPatchSettings, VirtualMachineWinRMConfiguration, VirtualMachineWinRMListener, VirtualMachineOSProfile, VirtualMachineSecret, VirtualMachineSubResource, VirtualMachineVaultCertificate, VirtualMachineIdentity, VirtualMachinePlan, VirtualMachineAdditionalCapabilities, VirtualMachineBootDiagnostics, VirtualMachineDiagnosticsProfile, VirtualMachinePriorityProfile, VirtualMachineBillingProfile, VirtualMachineSecurityProfile, VirtualMachineUefiSettings, VirtualMachineAvailabilitySetReference, VirtualMachineScaleSetReference, VirtualMachineProximityPlacementGroupReference, VirtualMachineHostReference, VirtualMachineLicenseType, VirtualMachineMonitoringOptions, } from "./virtual-machine-schemas";

package/lib/azure-virtualmachine/lib/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Azure Virtual Machine Constructs using VersionedAzapiResource Framework
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIRTUAL_MACHINE_VERSION_2025_04_01 = exports.VIRTUAL_MACHINE_VERSION_2024_11_01 = exports.VIRTUAL_MACHINE_VERSION_2024_07_01 = exports.VIRTUAL_MACHINE_SCHEMA_2025_04_01 = exports.VIRTUAL_MACHINE_SCHEMA_2024_11_01 = exports.VIRTUAL_MACHINE_SCHEMA_2024_07_01 = exports.ALL_VIRTUAL_MACHINE_VERSIONS = exports.VIRTUAL_MACHINE_TYPE = exports.VirtualMachine = void 0;
+// Export the unified implementation
+__exportStar(require("./virtual-machine"), exports);
+// Export schemas for advanced usage
+__exportStar(require("./virtual-machine-schemas"), exports);
+// Explicit exports for main class and interfaces
+var virtual_machine_1 = require("./virtual-machine");
+Object.defineProperty(exports, "VirtualMachine", { enumerable: true, get: function () { return virtual_machine_1.VirtualMachine; } });
+// Schema exports
+var virtual_machine_schemas_1 = require("./virtual-machine-schemas");
+Object.defineProperty(exports, "VIRTUAL_MACHINE_TYPE", { enumerable: true, get: function () { return virtual_machine_schemas_1.VIRTUAL_MACHINE_TYPE; } });
+Object.defineProperty(exports, "ALL_VIRTUAL_MACHINE_VERSIONS", { enumerable: true, get: function () { return virtual_machine_schemas_1.ALL_VIRTUAL_MACHINE_VERSIONS; } });
+Object.defineProperty(exports, "VIRTUAL_MACHINE_SCHEMA_2024_07_01", { enumerable: true, get: function () { return virtual_machine_schemas_1.VIRTUAL_MACHINE_SCHEMA_2024_07_01; } });
+Object.defineProperty(exports, "VIRTUAL_MACHINE_SCHEMA_2024_11_01", { enumerable: true, get: function () { return virtual_machine_schemas_1.VIRTUAL_MACHINE_SCHEMA_2024_11_01; } });
+Object.defineProperty(exports, "VIRTUAL_MACHINE_SCHEMA_2025_04_01", { enumerable: true, get: function () { return virtual_machine_schemas_1.VIRTUAL_MACHINE_SCHEMA_2025_04_01; } });
+Object.defineProperty(exports, "VIRTUAL_MACHINE_VERSION_2024_07_01", { enumerable: true, get: function () { return virtual_machine_schemas_1.VIRTUAL_MACHINE_VERSION_2024_07_01; } });
+Object.defineProperty(exports, "VIRTUAL_MACHINE_VERSION_2024_11_01", { enumerable: true, get: function () { return virtual_machine_schemas_1.VIRTUAL_MACHINE_VERSION_2024_11_01; } });
+Object.defineProperty(exports, "VIRTUAL_MACHINE_VERSION_2025_04_01", { enumerable: true, get: function () { return virtual_machine_schemas_1.VIRTUAL_MACHINE_VERSION_2025_04_01; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtdmlydHVhbG1hY2hpbmUvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7R0FFRzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCxvQ0FBb0M7QUFDcEMsb0RBQWtDO0FBRWxDLG9DQUFvQztBQUNwQyw0REFBMEM7QUFFMUMsaURBQWlEO0FBQ2pELHFEQUFtRDtBQUExQyxpSEFBQSxjQUFjLE9BQUE7QUFLdkIsaUJBQWlCO0FBQ2pCLHFFQVNtQztBQVJqQywrSEFBQSxvQkFBb0IsT0FBQTtBQUNwQix1SUFBQSw0QkFBNEIsT0FBQTtBQUM1Qiw0SUFBQSxpQ0FBaUMsT0FBQTtBQUNqQyw0SUFBQSxpQ0FBaUMsT0FBQTtBQUNqQyw0SUFBQSxpQ0FBaUMsT0FBQTtBQUNqQyw2SUFBQSxrQ0FBa0MsT0FBQTtBQUNsQyw2SUFBQSxrQ0FBa0MsT0FBQTtBQUNsQyw2SUFBQSxrQ0FBa0MsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQXp1cmUgVmlydHVhbCBNYWNoaW5lIENvbnN0cnVjdHMgdXNpbmcgVmVyc2lvbmVkQXphcGlSZXNvdXJjZSBGcmFtZXdvcmtcbiAqL1xuXG4vLyBFeHBvcnQgdGhlIHVuaWZpZWQgaW1wbGVtZW50YXRpb25cbmV4cG9ydCAqIGZyb20gXCIuL3ZpcnR1YWwtbWFjaGluZVwiO1xuXG4vLyBFeHBvcnQgc2NoZW1hcyBmb3IgYWR2YW5jZWQgdXNhZ2VcbmV4cG9ydCAqIGZyb20gXCIuL3ZpcnR1YWwtbWFjaGluZS1zY2hlbWFzXCI7XG5cbi8vIEV4cGxpY2l0IGV4cG9ydHMgZm9yIG1haW4gY2xhc3MgYW5kIGludGVyZmFjZXNcbmV4cG9ydCB7IFZpcnR1YWxNYWNoaW5lIH0gZnJvbSBcIi4vdmlydHVhbC1tYWNoaW5lXCI7XG5leHBvcnQgdHlwZSB7IFZpcnR1YWxNYWNoaW5lUHJvcHMgfSBmcm9tIFwiLi92aXJ0dWFsLW1hY2hpbmVcIjtcbmV4cG9ydCB0eXBlIHsgVmlydHVhbE1hY2hpbmVCb2R5IH0gZnJvbSBcIi4vdmlydHVhbC1tYWNoaW5lXCI7XG5leHBvcnQgdHlwZSB7IFZpcnR1YWxNYWNoaW5lQm9keVByb3BlcnRpZXMgfSBmcm9tIFwiLi92aXJ0dWFsLW1hY2hpbmVcIjtcblxuLy8gU2NoZW1hIGV4cG9ydHNcbmV4cG9ydCB7XG4gIFZJUlRVQUxfTUFDSElORV9UWVBFLFxuICBBTExfVklSVFVBTF9NQUNISU5FX1ZFUlNJT05TLFxuICBWSVJUVUFMX01BQ0hJTkVfU0NIRU1BXzIwMjRfMDdfMDEsXG4gIFZJUlRVQUxfTUFDSElORV9TQ0hFTUFfMjAyNF8xMV8wMSxcbiAgVklSVFVBTF9NQUNISU5FX1NDSEVNQV8yMDI1XzA0XzAxLFxuICBWSVJUVUFMX01BQ0hJTkVfVkVSU0lPTl8yMDI0XzA3XzAxLFxuICBWSVJUVUFMX01BQ0hJTkVfVkVSU0lPTl8yMDI0XzExXzAxLFxuICBWSVJUVUFMX01BQ0hJTkVfVkVSU0lPTl8yMDI1XzA0XzAxLFxufSBmcm9tIFwiLi92aXJ0dWFsLW1hY2hpbmUtc2NoZW1hc1wiO1xuXG4vLyBFeHBvcnQgYWxsIFR5cGVTY3JpcHQgaW50ZXJmYWNlcyBmb3IgbmVzdGVkIG9iamVjdHNcbmV4cG9ydCB0eXBlIHtcbiAgVmlydHVhbE1hY2hpbmVIYXJkd2FyZVByb2ZpbGUsXG4gIFZpcnR1YWxNYWNoaW5lSW1hZ2VSZWZlcmVuY2UsXG4gIFZpcnR1YWxNYWNoaW5lT1NEaXNrLFxuICBWaXJ0dWFsTWFjaGluZURhdGFEaXNrLFxuICBWaXJ0dWFsTWFjaGluZU1hbmFnZWREaXNrUGFyYW1ldGVycyxcbiAgVmlydHVhbE1hY2hpbmVEaXNrRW5jcnlwdGlvblNldFBhcmFtZXRlcnMsXG4gIFZpcnR1YWxNYWNoaW5lU3RvcmFnZVByb2ZpbGUsXG4gIFZpcnR1YWxNYWNoaW5lTmV0d29ya0ludGVyZmFjZVJlZmVyZW5jZSxcbiAgVmlydHVhbE1hY2hpbmVOZXR3b3JrUHJvZmlsZSxcbiAgVmlydHVhbE1hY2hpbmVTc2hQdWJsaWNLZXksXG4gIFZpcnR1YWxNYWNoaW5lU3NoQ29uZmlndXJhdGlvbixcbiAgVmlydHVhbE1hY2hpbmVMaW51eENvbmZpZ3VyYXRpb24sXG4gIFZpcnR1YWxNYWNoaW5lTGludXhQYXRjaFNldHRpbmdzLFxuICBWaXJ0dWFsTWFjaGluZVdpbmRvd3NDb25maWd1cmF0aW9uLFxuICBWaXJ0dWFsTWFjaGluZVdpbmRvd3NQYXRjaFNldHRpbmdzLFxuICBWaXJ0dWFsTWFjaGluZVdpblJNQ29uZmlndXJhdGlvbixcbiAgVmlydHVhbE1hY2hpbmVXaW5STUxpc3RlbmVyLFxuICBWaXJ0dWFsTWFjaGluZU9TUHJvZmlsZSxcbiAgVmlydHVhbE1hY2hpbmVTZWNyZXQsXG4gIFZpcnR1YWxNYWNoaW5lU3ViUmVzb3VyY2UsXG4gIFZpcnR1YWxNYWNoaW5lVmF1bHRDZXJ0aWZpY2F0ZSxcbiAgVmlydHVhbE1hY2hpbmVJZGVudGl0eSxcbiAgVmlydHVhbE1hY2hpbmVQbGFuLFxuICBWaXJ0dWFsTWFjaGluZUFkZGl0aW9uYWxDYXBhYmlsaXRpZXMsXG4gIFZpcnR1YWxNYWNoaW5lQm9vdERpYWdub3N0aWNzLFxuICBWaXJ0dWFsTWFjaGluZURpYWdub3N0aWNzUHJvZmlsZSxcbiAgVmlydHVhbE1hY2hpbmVQcmlvcml0eVByb2ZpbGUsXG4gIFZpcnR1YWxNYWNoaW5lQmlsbGluZ1Byb2ZpbGUsXG4gIFZpcnR1YWxNYWNoaW5lU2VjdXJpdHlQcm9maWxlLFxuICBWaXJ0dWFsTWFjaGluZVVlZmlTZXR0aW5ncyxcbiAgVmlydHVhbE1hY2hpbmVBdmFpbGFiaWxpdHlTZXRSZWZlcmVuY2UsXG4gIFZpcnR1YWxNYWNoaW5lU2NhbGVTZXRSZWZlcmVuY2UsXG4gIFZpcnR1YWxNYWNoaW5lUHJveGltaXR5UGxhY2VtZW50R3JvdXBSZWZlcmVuY2UsXG4gIFZpcnR1YWxNYWNoaW5lSG9zdFJlZmVyZW5jZSxcbiAgVmlydHVhbE1hY2hpbmVMaWNlbnNlVHlwZSxcbiAgVmlydHVhbE1hY2hpbmVNb25pdG9yaW5nT3B0aW9ucyxcbn0gZnJvbSBcIi4vdmlydHVhbC1tYWNoaW5lLXNjaGVtYXNcIjtcbiJdfQ==