@microsoft/terraform-cdk-constructs 1.0.0 → 1.3.0

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

@@ -0,0 +1,19 @@
+"use strict";
+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("./dns-zone-schemas"), exports);
+__exportStar(require("./dns-zone"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtZG5zem9uZS9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHFEQUFtQztBQUNuQyw2Q0FBMkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9kbnMtem9uZS1zY2hlbWFzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kbnMtem9uZVwiO1xuIl19

package/lib/azure-dnszone/test/dns-zone.integ.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration test for Azure DNS Zone
+ *
+ * This test demonstrates basic usage of the DnsZone construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+import "cdktf/lib/testing/adapters/jest";

package/lib/azure-dnszone/test/dns-zone.integ.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Integration test for Azure DNS Zone
+ *
+ * This test demonstrates basic usage of the DnsZone construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const resource_group_1 = require("../../azure-resourcegroup/lib/resource-group");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const testing_1 = require("../../testing");
+const metadata_1 = require("../../testing/lib/metadata");
+const dns_zone_1 = require("../lib/dns-zone");
+// Generate unique test run metadata for this test suite
+const testMetadata = new metadata_1.TestRunMetadata("dnszone-integration", {
+    maxAgeHours: 4,
+});
+/**
+ * Example stack demonstrating DNS Zone usage
+ */
+class DnsZoneExampleStack extends testing_1.BaseTestStack {
+    constructor(scope, id) {
+        super(scope, id, {
+            testRunOptions: {
+                maxAgeHours: testMetadata.maxAgeHours,
+                autoCleanup: testMetadata.autoCleanup,
+                cleanupPolicy: testMetadata.cleanupPolicy,
+            },
+        });
+        // Configure AZAPI provider
+        new provider_1.AzapiProvider(this, "azapi", {});
+        // Generate unique names
+        const resourceGroupName = this.generateResourceName("Microsoft.Resources/resourceGroups", "dnszone");
+        const dnsZoneName = this.generateResourceName("Microsoft.Network/dnsZones", "basic");
+        // Create resource group for the DNS zone
+        const resourceGroup = new resource_group_1.ResourceGroup(this, "test-rg", {
+            name: resourceGroupName,
+            location: "eastus",
+            tags: {
+                ...this.systemTags(),
+                purpose: "dns-zone-testing",
+            },
+        });
+        // Example 1: Basic public DNS zone
+        new dns_zone_1.DnsZone(this, "basic-dns-zone", {
+            name: `${dnsZoneName}.com`,
+            location: "global",
+            resourceGroupId: resourceGroup.id,
+            tags: {
+                ...this.systemTags(),
+                example: "basic",
+            },
+        });
+        // Example 2: Public DNS zone with explicit tags
+        new dns_zone_1.DnsZone(this, "tagged-dns-zone", {
+            name: `${dnsZoneName}-tagged.com`,
+            location: "global",
+            resourceGroupId: resourceGroup.id,
+            zoneType: "Public",
+            tags: {
+                ...this.systemTags(),
+                example: "tagged",
+                environment: "test",
+                owner: "integration-test",
+            },
+        });
+    }
+}
+describe("DnsZone Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new DnsZoneExampleStack(app, "test-dnszone");
+        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources
+        // 2. Run terraform plan to check idempotency (no changes expected)
+        // 3. Run terraform destroy to cleanup resources
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized, { verifyCleanup: true });
+    }, 600000); // 10 minute timeout for deployment and cleanup
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-dnszone/test/dns-zone.spec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Comprehensive tests for the unified DnsZone implementation
+ *
+ * This test suite validates the unified DnsZone class using the
+ * VersionedAzapiResource framework. Tests cover automatic version resolution,
+ * explicit version pinning, schema validation, property transformation, and
+ * full backward compatibility.
+ */
+export {};

package/lib/azure-dnszone/test/dns-zone.spec.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Comprehensive tests for the unified DnsZone implementation
+ *
+ * This test suite validates the unified DnsZone class using the
+ * VersionedAzapiResource framework. Tests cover automatic version resolution,
+ * explicit version pinning, schema validation, property transformation, and
+ * full backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const dns_zone_1 = require("../lib/dns-zone");
+const dns_zone_schemas_1 = require("../lib/dns-zone-schemas");
+describe("DnsZone - Unified Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        // Ensure schemas are registered
+        try {
+            manager.registerResourceType(dns_zone_schemas_1.DNS_ZONE_TYPE, dns_zone_schemas_1.ALL_DNS_ZONE_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create DNS zone with automatic latest version resolution", () => {
+            const props = {
+                name: "contoso.com",
+                location: "global",
+            };
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", props);
+            expect(dnsZone).toBeInstanceOf(dns_zone_1.DnsZone);
+            expect(dnsZone.resolvedApiVersion).toBe("2018-05-01");
+            expect(dnsZone.props).toBe(props);
+        });
+        it("should create DNS zone with explicit version pinning", () => {
+            const props = {
+                name: "contoso.com",
+                location: "global",
+                apiVersion: "2018-05-01",
+                tags: { environment: "test" },
+            };
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", props);
+            expect(dnsZone.resolvedApiVersion).toBe("2018-05-01");
+            expect(dnsZone.tags).toEqual({ environment: "test" });
+        });
+        it("should create public DNS zone by default", () => {
+            const props = {
+                name: "contoso.com",
+                location: "global",
+            };
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", props);
+            expect(dnsZone.zoneType).toBe("Public");
+        });
+        it("should create private DNS zone when specified", () => {
+            const props = {
+                name: "internal.contoso.com",
+                location: "global",
+                zoneType: "Private",
+                registrationVirtualNetworks: [
+                    {
+                        id: "/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet1",
+                    },
+                ],
+            };
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", props);
+            expect(dnsZone.zoneType).toBe("Private");
+        });
+        it("should use global location by default", () => {
+            const props = {
+                name: "contoso.com",
+            };
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", props);
+            expect(dnsZone.location).toBe("global");
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            expect(dnsZone.resolvedApiVersion).toBe("2018-05-01");
+            expect(dnsZone.latestVersion()).toBe("2018-05-01");
+        });
+        it("should provide version configuration", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            expect(dnsZone.versionConfig).toBeDefined();
+            expect(dnsZone.versionConfig.version).toBe("2018-05-01");
+            expect(dnsZone.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+        it("should provide supported versions", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            const versions = dnsZone.supportedVersions();
+            expect(versions).toContain("2018-05-01");
+            expect(versions.length).toBeGreaterThan(0);
+        });
+    });
+    describe("Public Methods", () => {
+        it("should provide name servers output", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            expect(dnsZone.nameServers).toBeDefined();
+            expect(typeof dnsZone.nameServers).toBe("string");
+        });
+        it("should provide max number of record sets", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            expect(dnsZone.maxNumberOfRecordSets).toBeDefined();
+        });
+        it("should provide current number of record sets", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            expect(dnsZone.numberOfRecordSets).toBeDefined();
+        });
+        it("should allow adding tags", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+                tags: { initial: "tag" },
+            });
+            dnsZone.addTag("newKey", "newValue");
+            expect(dnsZone.props.tags).toHaveProperty("newKey", "newValue");
+            expect(dnsZone.props.tags).toHaveProperty("initial", "tag");
+        });
+        it("should allow removing tags", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+                tags: { key1: "value1", key2: "value2" },
+            });
+            dnsZone.removeTag("key1");
+            expect(dnsZone.props.tags).not.toHaveProperty("key1");
+            expect(dnsZone.props.tags).toHaveProperty("key2", "value2");
+        });
+    });
+    describe("Outputs", () => {
+        it("should create all required outputs", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            expect(dnsZone.idOutput).toBeDefined();
+            expect(dnsZone.locationOutput).toBeDefined();
+            expect(dnsZone.nameOutput).toBeDefined();
+            expect(dnsZone.tagsOutput).toBeDefined();
+            expect(dnsZone.nameServersOutput).toBeDefined();
+        });
+        it("should have correct logical IDs for outputs", () => {
+            new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain('"id"');
+            expect(synthesized).toContain('"location"');
+            expect(synthesized).toContain('"name"');
+            expect(synthesized).toContain('"tags"');
+            expect(synthesized).toContain('"name_servers"');
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+                ignoreChanges: ["tags"],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("ignore_changes");
+        });
+        it("should handle multiple ignore changes properties", () => {
+            new dns_zone_1.DnsZone(stack, "TestDnsZone2", {
+                name: "contoso2.com",
+                location: "global",
+                ignoreChanges: ["tags", "location"],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new dns_zone_1.DnsZone(stack, "SynthTest", {
+                name: "contoso.com",
+                location: "global",
+                tags: { test: "synthesis" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should generate correct resource type in Terraform", () => {
+            new dns_zone_1.DnsZone(stack, "SynthTest", {
+                name: "contoso.com",
+                location: "global",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("Microsoft.Network/dnsZones");
+            expect(synthesized).toContain("2018-05-01");
+        });
+        it("should include all properties in Terraform body", () => {
+            new dns_zone_1.DnsZone(stack, "SynthTest", {
+                name: "contoso.com",
+                location: "global",
+                tags: { env: "test" },
+                zoneType: "Public",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            const stackConfig = JSON.parse(synthesized);
+            // Verify the resource exists
+            expect(stackConfig.resource).toBeDefined();
+            expect(stackConfig.resource.azapi_resource).toBeDefined();
+            // Get the resource
+            const resources = Object.values(stackConfig.resource.azapi_resource);
+            expect(resources.length).toBeGreaterThan(0);
+            const resource = resources[0];
+            // Verify tags are at the resource level (not in body)
+            expect(resource.tags).toEqual({ env: "test" });
+            // Verify body contains location
+            expect(resource.body.location).toBe("global");
+        });
+    });
+    describe("Private DNS Zone Features", () => {
+        it("should create private DNS zone with virtual network references", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "PrivateDnsZone", {
+                name: "internal.contoso.com",
+                location: "global",
+                zoneType: "Private",
+                registrationVirtualNetworks: [
+                    {
+                        id: "/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet1",
+                    },
+                ],
+                resolutionVirtualNetworks: [
+                    {
+                        id: "/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2",
+                    },
+                ],
+            });
+            expect(dnsZone.zoneType).toBe("Private");
+            expect(dnsZone.props.registrationVirtualNetworks).toHaveLength(1);
+            expect(dnsZone.props.resolutionVirtualNetworks).toHaveLength(1);
+        });
+    });
+    describe("Resource Identification", () => {
+        it("should provide resource ID", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            expect(dnsZone.id).toBeDefined();
+            expect(typeof dnsZone.id).toBe("string");
+        });
+        it("should provide resource name from props", () => {
+            const dnsZone = new dns_zone_1.DnsZone(stack, "TestDnsZone", {
+                name: "contoso.com",
+                location: "global",
+            });
+            expect(dnsZone.name).toBe("contoso.com");
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dns-zone.spec.js","sourceRoot":"","sources":["../../../src/azure-dnszone/test/dns-zone.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for the unified DnsZone implementation\n *\n * This test suite validates the unified DnsZone class using the\n * VersionedAzapiResource framework. Tests cover automatic version resolution,\n * explicit version pinning, schema validation, property transformation, and\n * full backward compatibility.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { VersionSupportLevel } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\nimport { DnsZone, DnsZoneProps } from \"../lib/dns-zone\";\nimport { ALL_DNS_ZONE_VERSIONS, DNS_ZONE_TYPE } from \"../lib/dns-zone-schemas\";\n\ndescribe(\"DnsZone - Unified Implementation\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n  let manager: ApiVersionManager;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    // Ensure schemas are registered\n    try {\n      manager.registerResourceType(DNS_ZONE_TYPE, ALL_DNS_ZONE_VERSIONS);\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create DNS zone with automatic latest version resolution\", () => {\n      const props: DnsZoneProps = {\n        name: \"contoso.com\",\n        location: \"global\",\n      };\n\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", props);\n\n      expect(dnsZone).toBeInstanceOf(DnsZone);\n      expect(dnsZone.resolvedApiVersion).toBe(\"2018-05-01\");\n      expect(dnsZone.props).toBe(props);\n    });\n\n    it(\"should create DNS zone with explicit version pinning\", () => {\n      const props: DnsZoneProps = {\n        name: \"contoso.com\",\n        location: \"global\",\n        apiVersion: \"2018-05-01\",\n        tags: { environment: \"test\" },\n      };\n\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", props);\n\n      expect(dnsZone.resolvedApiVersion).toBe(\"2018-05-01\");\n      expect(dnsZone.tags).toEqual({ environment: \"test\" });\n    });\n\n    it(\"should create public DNS zone by default\", () => {\n      const props: DnsZoneProps = {\n        name: \"contoso.com\",\n        location: \"global\",\n      };\n\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", props);\n\n      expect(dnsZone.zoneType).toBe(\"Public\");\n    });\n\n    it(\"should create private DNS zone when specified\", () => {\n      const props: DnsZoneProps = {\n        name: \"internal.contoso.com\",\n        location: \"global\",\n        zoneType: \"Private\",\n        registrationVirtualNetworks: [\n          {\n            id: \"/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet1\",\n          },\n        ],\n      };\n\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", props);\n\n      expect(dnsZone.zoneType).toBe(\"Private\");\n    });\n\n    it(\"should use global location by default\", () => {\n      const props: DnsZoneProps = {\n        name: \"contoso.com\",\n      };\n\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", props);\n\n      expect(dnsZone.location).toBe(\"global\");\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      expect(dnsZone.resolvedApiVersion).toBe(\"2018-05-01\");\n      expect(dnsZone.latestVersion()).toBe(\"2018-05-01\");\n    });\n\n    it(\"should provide version configuration\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      expect(dnsZone.versionConfig).toBeDefined();\n      expect(dnsZone.versionConfig.version).toBe(\"2018-05-01\");\n      expect(dnsZone.versionConfig.supportLevel).toBe(\n        VersionSupportLevel.ACTIVE,\n      );\n    });\n\n    it(\"should provide supported versions\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      const versions = dnsZone.supportedVersions();\n      expect(versions).toContain(\"2018-05-01\");\n      expect(versions.length).toBeGreaterThan(0);\n    });\n  });\n\n  describe(\"Public Methods\", () => {\n    it(\"should provide name servers output\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      expect(dnsZone.nameServers).toBeDefined();\n      expect(typeof dnsZone.nameServers).toBe(\"string\");\n    });\n\n    it(\"should provide max number of record sets\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      expect(dnsZone.maxNumberOfRecordSets).toBeDefined();\n    });\n\n    it(\"should provide current number of record sets\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      expect(dnsZone.numberOfRecordSets).toBeDefined();\n    });\n\n    it(\"should allow adding tags\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n        tags: { initial: \"tag\" },\n      });\n\n      dnsZone.addTag(\"newKey\", \"newValue\");\n      expect(dnsZone.props.tags).toHaveProperty(\"newKey\", \"newValue\");\n      expect(dnsZone.props.tags).toHaveProperty(\"initial\", \"tag\");\n    });\n\n    it(\"should allow removing tags\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n        tags: { key1: \"value1\", key2: \"value2\" },\n      });\n\n      dnsZone.removeTag(\"key1\");\n      expect(dnsZone.props.tags).not.toHaveProperty(\"key1\");\n      expect(dnsZone.props.tags).toHaveProperty(\"key2\", \"value2\");\n    });\n  });\n\n  describe(\"Outputs\", () => {\n    it(\"should create all required outputs\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      expect(dnsZone.idOutput).toBeDefined();\n      expect(dnsZone.locationOutput).toBeDefined();\n      expect(dnsZone.nameOutput).toBeDefined();\n      expect(dnsZone.tagsOutput).toBeDefined();\n      expect(dnsZone.nameServersOutput).toBeDefined();\n    });\n\n    it(\"should have correct logical IDs for outputs\", () => {\n      new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain('\"id\"');\n      expect(synthesized).toContain('\"location\"');\n      expect(synthesized).toContain('\"name\"');\n      expect(synthesized).toContain('\"tags\"');\n      expect(synthesized).toContain('\"name_servers\"');\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n        ignoreChanges: [\"tags\"],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"ignore_changes\");\n    });\n\n    it(\"should handle multiple ignore changes properties\", () => {\n      new DnsZone(stack, \"TestDnsZone2\", {\n        name: \"contoso2.com\",\n        location: \"global\",\n        ignoreChanges: [\"tags\", \"location\"],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new DnsZone(stack, \"SynthTest\", {\n        name: \"contoso.com\",\n        location: \"global\",\n        tags: { test: \"synthesis\" },\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 generate correct resource type in Terraform\", () => {\n      new DnsZone(stack, \"SynthTest\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"Microsoft.Network/dnsZones\");\n      expect(synthesized).toContain(\"2018-05-01\");\n    });\n\n    it(\"should include all properties in Terraform body\", () => {\n      new DnsZone(stack, \"SynthTest\", {\n        name: \"contoso.com\",\n        location: \"global\",\n        tags: { env: \"test\" },\n        zoneType: \"Public\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      const stackConfig = JSON.parse(synthesized);\n\n      // Verify the resource exists\n      expect(stackConfig.resource).toBeDefined();\n      expect(stackConfig.resource.azapi_resource).toBeDefined();\n\n      // Get the resource\n      const resources = Object.values(stackConfig.resource.azapi_resource);\n      expect(resources.length).toBeGreaterThan(0);\n      const resource: any = resources[0];\n\n      // Verify tags are at the resource level (not in body)\n      expect(resource.tags).toEqual({ env: \"test\" });\n\n      // Verify body contains location\n      expect(resource.body.location).toBe(\"global\");\n    });\n  });\n\n  describe(\"Private DNS Zone Features\", () => {\n    it(\"should create private DNS zone with virtual network references\", () => {\n      const dnsZone = new DnsZone(stack, \"PrivateDnsZone\", {\n        name: \"internal.contoso.com\",\n        location: \"global\",\n        zoneType: \"Private\",\n        registrationVirtualNetworks: [\n          {\n            id: \"/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet1\",\n          },\n        ],\n        resolutionVirtualNetworks: [\n          {\n            id: \"/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/vnet2\",\n          },\n        ],\n      });\n\n      expect(dnsZone.zoneType).toBe(\"Private\");\n      expect(dnsZone.props.registrationVirtualNetworks).toHaveLength(1);\n      expect(dnsZone.props.resolutionVirtualNetworks).toHaveLength(1);\n    });\n  });\n\n  describe(\"Resource Identification\", () => {\n    it(\"should provide resource ID\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      expect(dnsZone.id).toBeDefined();\n      expect(typeof dnsZone.id).toBe(\"string\");\n    });\n\n    it(\"should provide resource name from props\", () => {\n      const dnsZone = new DnsZone(stack, \"TestDnsZone\", {\n        name: \"contoso.com\",\n        location: \"global\",\n      });\n\n      expect(dnsZone.name).toBe(\"contoso.com\");\n    });\n  });\n});\n"]}

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

@@ -0,0 +1 @@
+export * from "./lib";

package/lib/azure-metricalert/index.js

@@ -0,0 +1,18 @@
+"use strict";
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtbWV0cmljYWxlcnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2xpYlwiO1xuIl19

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

@@ -0,0 +1,2 @@
+export * from "./metric-alert-schemas";
+export * from "./metric-alert";

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

@@ -0,0 +1,19 @@
+"use strict";
+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("./metric-alert-schemas"), exports);
+__exportStar(require("./metric-alert"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtbWV0cmljYWxlcnQvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx5REFBdUM7QUFDdkMsaURBQStCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vbWV0cmljLWFsZXJ0LXNjaGVtYXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL21ldHJpYy1hbGVydFwiO1xuIl19

package/lib/azure-metricalert/lib/metric-alert-schemas.d.ts

@@ -0,0 +1,24 @@
+/**
+ * API schemas for Azure Metric Alert across all supported versions
+ *
+ * This file defines the complete API schemas for Microsoft.Insights/metricAlerts
+ * across all supported API versions. The schemas are used by the AzapiResource
+ * framework for validation, transformation, and version management.
+ */
+import { ApiSchema, VersionConfig } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+/**
+ * API Schema for Metric Alert version 2018-03-01
+ */
+export declare const METRIC_ALERT_SCHEMA_2018_03_01: ApiSchema;
+/**
+ * Version configuration for Metric Alert 2018-03-01
+ */
+export declare const METRIC_ALERT_VERSION_2018_03_01: VersionConfig;
+/**
+ * All supported Metric Alert versions for registration
+ */
+export declare const ALL_METRIC_ALERT_VERSIONS: VersionConfig[];
+/**
+ * Resource type constant
+ */
+export declare const METRIC_ALERT_TYPE = "Microsoft.Insights/metricAlerts";