@microsoft/terraform-cdk-constructs 1.7.1 → 1.9.0

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

@@ -0,0 +1,950 @@
+"use strict";
+/**
+ * Unit tests for Azure Public DNS Zone Record implementations
+ *
+ * This test suite validates all 10 Public DNS record types:
+ * - DnsARecord
+ * - DnsAaaaRecord
+ * - DnsCaaRecord (Public DNS only)
+ * - DnsCnameRecord
+ * - DnsMxRecord
+ * - DnsNsRecord (Public DNS only)
+ * - DnsPtrRecord
+ * - DnsSoaRecord
+ * - DnsSrvRecord
+ * - DnsTxtRecord
+ *
+ * Tests verify basic creation, correct resource types, API versions,
+ * parent ID resolution, resource body structure, TTL handling,
+ * record-specific properties, metadata handling, and alias record support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const records_1 = require("../lib/records");
+const dns_record_schemas_1 = require("../lib/records/dns-record-schemas");
+// Sample DNS Zone ID for testing
+const SAMPLE_ZONE_ID = "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg-test/providers/Microsoft.Network/dnsZones/example.com";
+// Sample Public IP ID for alias record testing
+const SAMPLE_PUBLIC_IP_ID = "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg-test/providers/Microsoft.Network/publicIPAddresses/myPublicIP";
+describe("DnsARecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create an A record with required properties", () => {
+            const record = new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsARecord);
+            expect(record.props.name).toBe("www");
+            expect(record.props.dnsZoneId).toBe(SAMPLE_ZONE_ID);
+            expect(record.props.records).toHaveLength(1);
+            expect(record.props.records[0].ipv4Address).toBe("20.30.40.50");
+        });
+        it("should create an A record with multiple IP addresses", () => {
+            const record = new records_1.DnsARecord(stack, "test-a-record-multi", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { ipv4Address: "20.30.40.50" },
+                    { ipv4Address: "20.30.40.51" },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+        it("should create an apex A record with @ name", () => {
+            const record = new records_1.DnsARecord(stack, "test-a-record-apex", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            expect(record.props.name).toBe("@");
+        });
+    });
+    describe("Alias Record Support", () => {
+        it("should create an alias A record with targetResourceId", () => {
+            const record = new records_1.DnsARecord(stack, "test-a-record-alias", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                targetResourceId: SAMPLE_PUBLIC_IP_ID,
+            });
+            expect(record.props.targetResourceId).toBe(SAMPLE_PUBLIC_IP_ID);
+            expect(record.props.records).toBeUndefined();
+        });
+        it("should include targetResource in synthesized output for alias records", () => {
+            new records_1.DnsARecord(stack, "test-a-record-alias", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                targetResourceId: SAMPLE_PUBLIC_IP_ID,
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("targetResource");
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_A_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Parent ID Resolution", () => {
+        it("should set parentId to the zone ID", () => {
+            new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(SAMPLE_ZONE_ID);
+        });
+    });
+    describe("TTL Handling", () => {
+        it("should use default TTL of 3600 when not specified", () => {
+            new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("3600");
+        });
+        it("should use custom TTL when specified", () => {
+            new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                ttl: 300,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("300");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include ARecords in the body with PascalCase", () => {
+            new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("ARecords");
+            expect(synthesized).toContain("ipv4Address");
+            expect(synthesized).toContain("20.30.40.50");
+        });
+        it("should use TTL with uppercase in public DNS", () => {
+            new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("TTL");
+        });
+    });
+    describe("Metadata Handling", () => {
+        it("should include metadata when provided", () => {
+            new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+                metadata: { environment: "production", owner: "team-a" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("metadata");
+            expect(synthesized).toContain("environment");
+            expect(synthesized).toContain("production");
+        });
+    });
+    describe("Outputs", () => {
+        it("should create required outputs", () => {
+            const record = new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            expect(record.idOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(record.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(record.fqdnOutput).toBeInstanceOf(cdktf.TerraformOutput);
+        });
+        it("should provide fqdn property", () => {
+            const record = new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            expect(record.fqdn).toBeDefined();
+            expect(typeof record.fqdn).toBe("string");
+        });
+    });
+});
+describe("DnsAaaaRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create an AAAA record with required properties", () => {
+            const record = new records_1.DnsAaaaRecord(stack, "test-aaaa-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsAaaaRecord);
+            expect(record.props.name).toBe("www");
+            expect(record.props.records[0].ipv6Address).toBe("2001:db8::1");
+        });
+        it("should create an AAAA record with multiple IPv6 addresses", () => {
+            const record = new records_1.DnsAaaaRecord(stack, "test-aaaa-record-multi", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { ipv6Address: "2001:db8::1" },
+                    { ipv6Address: "2001:db8::2" },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+    });
+    describe("Alias Record Support", () => {
+        it("should create an alias AAAA record with targetResourceId", () => {
+            const record = new records_1.DnsAaaaRecord(stack, "test-aaaa-record-alias", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                targetResourceId: SAMPLE_PUBLIC_IP_ID,
+            });
+            expect(record.props.targetResourceId).toBe(SAMPLE_PUBLIC_IP_ID);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsAaaaRecord(stack, "test-aaaa-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_AAAA_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsAaaaRecord(stack, "test-aaaa-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include AAAARecords in the body with PascalCase", () => {
+            new records_1.DnsAaaaRecord(stack, "test-aaaa-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("AAAARecords");
+            expect(synthesized).toContain("ipv6Address");
+            expect(synthesized).toContain("2001:db8::1");
+        });
+    });
+});
+describe("DnsCaaRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create a CAA record with required properties", () => {
+            const record = new records_1.DnsCaaRecord(stack, "test-caa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ flags: 0, tag: "issue", value: "letsencrypt.org" }],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsCaaRecord);
+            expect(record.props.name).toBe("@");
+            expect(record.props.records[0].flags).toBe(0);
+            expect(record.props.records[0].tag).toBe("issue");
+            expect(record.props.records[0].value).toBe("letsencrypt.org");
+        });
+        it("should create a CAA record with multiple entries", () => {
+            const record = new records_1.DnsCaaRecord(stack, "test-caa-record-multi", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { flags: 0, tag: "issue", value: "letsencrypt.org" },
+                    { flags: 0, tag: "issuewild", value: ";" },
+                    { flags: 0, tag: "iodef", value: "mailto:security@example.com" },
+                ],
+            });
+            expect(record.props.records).toHaveLength(3);
+        });
+        it("should create a CAA record with critical flag", () => {
+            const record = new records_1.DnsCaaRecord(stack, "test-caa-record-critical", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ flags: 128, tag: "issue", value: "letsencrypt.org" }],
+            });
+            expect(record.props.records[0].flags).toBe(128);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsCaaRecord(stack, "test-caa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ flags: 0, tag: "issue", value: "letsencrypt.org" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_CAA_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsCaaRecord(stack, "test-caa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ flags: 0, tag: "issue", value: "letsencrypt.org" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include caaRecords in the body", () => {
+            new records_1.DnsCaaRecord(stack, "test-caa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ flags: 0, tag: "issue", value: "letsencrypt.org" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("caaRecords");
+            expect(synthesized).toContain("flags");
+            expect(synthesized).toContain("tag");
+            expect(synthesized).toContain("issue");
+        });
+    });
+});
+describe("DnsCnameRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create a CNAME record with required properties", () => {
+            const record = new records_1.DnsCnameRecord(stack, "test-cname-record", {
+                name: "app",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.example.com",
+            });
+            expect(record).toBeInstanceOf(records_1.DnsCnameRecord);
+            expect(record.props.name).toBe("app");
+            expect(record.props.cname).toBe("www.example.com");
+        });
+    });
+    describe("Alias Record Support", () => {
+        it("should create an alias CNAME record with targetResourceId", () => {
+            const record = new records_1.DnsCnameRecord(stack, "test-cname-record-alias", {
+                name: "app",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                targetResourceId: SAMPLE_PUBLIC_IP_ID,
+            });
+            expect(record.props.targetResourceId).toBe(SAMPLE_PUBLIC_IP_ID);
+            expect(record.props.cname).toBeUndefined();
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsCnameRecord(stack, "test-cname-record", {
+                name: "app",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.example.com",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_CNAME_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsCnameRecord(stack, "test-cname-record", {
+                name: "app",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.example.com",
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include CNAMERecord in the body with PascalCase", () => {
+            new records_1.DnsCnameRecord(stack, "test-cname-record", {
+                name: "app",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.example.com",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("CNAMERecord");
+            expect(synthesized).toContain("cname");
+            expect(synthesized).toContain("www.example.com");
+        });
+    });
+});
+describe("DnsMxRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create an MX record with required properties", () => {
+            const record = new records_1.DnsMxRecord(stack, "test-mx-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ preference: 10, exchange: "mail1.example.com" }],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsMxRecord);
+            expect(record.props.name).toBe("@");
+            expect(record.props.records[0].preference).toBe(10);
+            expect(record.props.records[0].exchange).toBe("mail1.example.com");
+        });
+        it("should create an MX record with multiple mail servers", () => {
+            const record = new records_1.DnsMxRecord(stack, "test-mx-record-multi", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { preference: 10, exchange: "mail1.example.com" },
+                    { preference: 20, exchange: "mail2.example.com" },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsMxRecord(stack, "test-mx-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ preference: 10, exchange: "mail1.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_MX_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsMxRecord(stack, "test-mx-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ preference: 10, exchange: "mail1.example.com" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include MXRecords in the body with PascalCase", () => {
+            new records_1.DnsMxRecord(stack, "test-mx-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ preference: 10, exchange: "mail1.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("MXRecords");
+            expect(synthesized).toContain("preference");
+            expect(synthesized).toContain("exchange");
+        });
+    });
+});
+describe("DnsNsRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create an NS record with required properties", () => {
+            const record = new records_1.DnsNsRecord(stack, "test-ns-record", {
+                name: "subdomain",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ nsdname: "ns1.subdomain.example.com" }],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsNsRecord);
+            expect(record.props.name).toBe("subdomain");
+            expect(record.props.records[0].nsdname).toBe("ns1.subdomain.example.com");
+        });
+        it("should create an NS record with multiple name servers", () => {
+            const record = new records_1.DnsNsRecord(stack, "test-ns-record-multi", {
+                name: "subdomain",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { nsdname: "ns1.subdomain.example.com" },
+                    { nsdname: "ns2.subdomain.example.com" },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsNsRecord(stack, "test-ns-record", {
+                name: "subdomain",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ nsdname: "ns1.subdomain.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_NS_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsNsRecord(stack, "test-ns-record", {
+                name: "subdomain",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ nsdname: "ns1.subdomain.example.com" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include NSRecords in the body with PascalCase", () => {
+            new records_1.DnsNsRecord(stack, "test-ns-record", {
+                name: "subdomain",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ nsdname: "ns1.subdomain.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("NSRecords");
+            expect(synthesized).toContain("nsdname");
+        });
+    });
+});
+describe("DnsPtrRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create a PTR record with required properties", () => {
+            const record = new records_1.DnsPtrRecord(stack, "test-ptr-record", {
+                name: "50",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ptrdname: "server1.example.com" }],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsPtrRecord);
+            expect(record.props.name).toBe("50");
+            expect(record.props.records[0].ptrdname).toBe("server1.example.com");
+        });
+        it("should create a PTR record with multiple targets", () => {
+            const record = new records_1.DnsPtrRecord(stack, "test-ptr-record-multi", {
+                name: "50",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { ptrdname: "server1.example.com" },
+                    { ptrdname: "server1-alias.example.com" },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsPtrRecord(stack, "test-ptr-record", {
+                name: "50",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ptrdname: "server1.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_PTR_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsPtrRecord(stack, "test-ptr-record", {
+                name: "50",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ptrdname: "server1.example.com" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include PTRRecords in the body with PascalCase", () => {
+            new records_1.DnsPtrRecord(stack, "test-ptr-record", {
+                name: "50",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ptrdname: "server1.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("PTRRecords");
+            expect(synthesized).toContain("ptrdname");
+        });
+    });
+});
+describe("DnsSoaRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create a SOA record with required properties", () => {
+            const record = new records_1.DnsSoaRecord(stack, "test-soa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                },
+            });
+            expect(record).toBeInstanceOf(records_1.DnsSoaRecord);
+            expect(record.props.name).toBe("@");
+            expect(record.props.soaRecord.email).toBe("admin.example.com");
+        });
+        it("should create a SOA record with all optional properties", () => {
+            const record = new records_1.DnsSoaRecord(stack, "test-soa-record-full", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                    host: "ns1.example.com",
+                    serialNumber: 1,
+                    refreshTime: 3600,
+                    retryTime: 300,
+                    expireTime: 2419200,
+                    minimumTTL: 300,
+                },
+            });
+            expect(record.props.soaRecord.host).toBe("ns1.example.com");
+            expect(record.props.soaRecord.refreshTime).toBe(3600);
+            expect(record.props.soaRecord.retryTime).toBe(300);
+            expect(record.props.soaRecord.expireTime).toBe(2419200);
+            expect(record.props.soaRecord.minimumTTL).toBe(300);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsSoaRecord(stack, "test-soa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_SOA_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsSoaRecord(stack, "test-soa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                },
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include SOARecord in the body with PascalCase", () => {
+            new records_1.DnsSoaRecord(stack, "test-soa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                    refreshTime: 3600,
+                },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("SOARecord");
+            expect(synthesized).toContain("email");
+            expect(synthesized).toContain("refreshTime");
+        });
+    });
+});
+describe("DnsSrvRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create an SRV record with required properties", () => {
+            const record = new records_1.DnsSrvRecord(stack, "test-srv-record", {
+                name: "_sip._tcp",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.example.com",
+                    },
+                ],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsSrvRecord);
+            expect(record.props.name).toBe("_sip._tcp");
+            expect(record.props.records[0].priority).toBe(10);
+            expect(record.props.records[0].weight).toBe(60);
+            expect(record.props.records[0].port).toBe(5060);
+            expect(record.props.records[0].target).toBe("sipserver1.example.com");
+        });
+        it("should create an SRV record with multiple servers", () => {
+            const record = new records_1.DnsSrvRecord(stack, "test-srv-record-multi", {
+                name: "_sip._tcp",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.example.com",
+                    },
+                    {
+                        priority: 10,
+                        weight: 40,
+                        port: 5060,
+                        target: "sipserver2.example.com",
+                    },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsSrvRecord(stack, "test-srv-record", {
+                name: "_sip._tcp",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.example.com",
+                    },
+                ],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_SRV_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsSrvRecord(stack, "test-srv-record", {
+                name: "_sip._tcp",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.example.com",
+                    },
+                ],
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include SRVRecords in the body with PascalCase", () => {
+            new records_1.DnsSrvRecord(stack, "test-srv-record", {
+                name: "_sip._tcp",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.example.com",
+                    },
+                ],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("SRVRecords");
+            expect(synthesized).toContain("priority");
+            expect(synthesized).toContain("weight");
+            expect(synthesized).toContain("port");
+            expect(synthesized).toContain("target");
+        });
+    });
+});
+describe("DnsTxtRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create a TXT record with required properties", () => {
+            const record = new records_1.DnsTxtRecord(stack, "test-txt-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { value: ["v=spf1 include:spf.protection.outlook.com -all"] },
+                ],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsTxtRecord);
+            expect(record.props.name).toBe("@");
+            expect(record.props.records[0].value).toContain("v=spf1 include:spf.protection.outlook.com -all");
+        });
+        it("should create a TXT record with multiple entries", () => {
+            const record = new records_1.DnsTxtRecord(stack, "test-txt-record-multi", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { value: ["v=spf1 include:spf.protection.outlook.com -all"] },
+                    { value: ["google-site-verification=abc123"] },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+        it("should handle TXT record with multiple string values", () => {
+            const record = new records_1.DnsTxtRecord(stack, "test-txt-record-split", {
+                name: "_dmarc",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        value: [
+                            "v=DMARC1;",
+                            "p=quarantine;",
+                            "rua=mailto:dmarc@example.com",
+                        ],
+                    },
+                ],
+            });
+            expect(record.props.records[0].value).toHaveLength(3);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.DnsTxtRecord(stack, "test-txt-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ value: ["v=spf1 -all"] }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_TXT_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.DnsTxtRecord(stack, "test-txt-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ value: ["v=spf1 -all"] }],
+            });
+            expect(record.resolvedApiVersion).toBe("2018-05-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include TXTRecords in the body with PascalCase", () => {
+            new records_1.DnsTxtRecord(stack, "test-txt-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ value: ["v=spf1 -all"] }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("TXTRecords");
+            expect(synthesized).toContain("value");
+        });
+    });
+});
+describe("Public DNS Records - Cross-cutting Concerns", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Multiple Record Types in Same Stack", () => {
+        it("should handle multiple record types in the same stack", () => {
+            new records_1.DnsARecord(stack, "a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            new records_1.DnsAaaaRecord(stack, "aaaa-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            new records_1.DnsCnameRecord(stack, "cname-record", {
+                name: "app",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.example.com",
+            });
+            new records_1.DnsCaaRecord(stack, "caa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ flags: 0, tag: "issue", value: "letsencrypt.org" }],
+            });
+            new records_1.DnsNsRecord(stack, "ns-record", {
+                name: "subdomain",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ nsdname: "ns1.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_A_RECORD_TYPE);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_AAAA_RECORD_TYPE);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_CNAME_RECORD_TYPE);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_CAA_RECORD_TYPE);
+            expect(synthesized).toContain(dns_record_schemas_1.DNS_NS_RECORD_TYPE);
+        });
+    });
+    describe("Terraform Synthesis", () => {
+        it("should synthesize valid Terraform configuration", () => {
+            new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+    });
+    describe("Public DNS vs Private DNS Differences", () => {
+        it("should use PascalCase property names for public DNS", () => {
+            new records_1.DnsARecord(stack, "test-a-record", {
+                name: "www",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "20.30.40.50" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            // Public DNS uses PascalCase (ARecords, TTL)
+            expect(synthesized).toContain("ARecords");
+            expect(synthesized).toContain("TTL");
+        });
+        it("should support CAA records (public DNS only)", () => {
+            const record = new records_1.DnsCaaRecord(stack, "caa-record", {
+                name: "@",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ flags: 0, tag: "issue", value: "letsencrypt.org" }],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsCaaRecord);
+        });
+        it("should support NS records (public DNS only)", () => {
+            const record = new records_1.DnsNsRecord(stack, "ns-record", {
+                name: "subdomain",
+                dnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ nsdname: "ns1.example.com" }],
+            });
+            expect(record).toBeInstanceOf(records_1.DnsNsRecord);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dns-records.spec.js","sourceRoot":"","sources":["../../../src/azure-dnszone/test/dns-records.spec.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;AAEH,iCAAgC;AAChC,+BAA+B;AAC/B,4CAWwB;AACxB,0EAW2C;AAE3C,iCAAiC;AACjC,MAAM,cAAc,GAClB,6HAA6H,CAAC;AAEhI,+CAA+C;AAC/C,MAAM,mBAAmB,GACvB,qIAAqI,CAAC;AAExI,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;IAC1B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;YAC5D,MAAM,MAAM,GAAG,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACpD,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,oBAAU,CAAC,CAAC;YAC1C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACtC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACpD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAC7C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAQ,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACnE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;YAC9D,MAAM,MAAM,GAAG,IAAI,oBAAU,CAAC,KAAK,EAAE,qBAAqB,EAAE;gBAC1D,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP,EAAE,WAAW,EAAE,aAAa,EAAE;oBAC9B,EAAE,WAAW,EAAE,aAAa,EAAE;iBAC/B;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;YACpD,MAAM,MAAM,GAAG,IAAI,oBAAU,CAAC,KAAK,EAAE,oBAAoB,EAAE;gBACzD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;QACpC,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,MAAM,MAAM,GAAG,IAAI,oBAAU,CAAC,KAAK,EAAE,qBAAqB,EAAE;gBAC1D,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,gBAAgB,EAAE,mBAAmB;aACtC,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YAChE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uEAAuE,EAAE,GAAG,EAAE;YAC/E,IAAI,oBAAU,CAAC,KAAK,EAAE,qBAAqB,EAAE;gBAC3C,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,gBAAgB,EAAE,mBAAmB;aACtC,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACrC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,sCAAiB,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACpD,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;QACpC,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;YAC5C,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACrC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;QAC5B,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;YAC3D,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACrC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;YAC9C,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACrC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,GAAG,EAAE,GAAG;gBACR,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACrC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;YAC1C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC7C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACrC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;QACjC,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;YAC/C,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACrC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;gBACzC,QAAQ,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE;aACzD,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;YAC1C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC7C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE;QACvB,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACpD,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAC9D,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAChE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;YACtC,MAAM,MAAM,GAAG,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACpD,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;YAClC,MAAM,CAAC,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,MAAM,MAAM,GAAG,IAAI,uBAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE;gBAC1D,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,uBAAa,CAAC,CAAC;YAC7C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACtC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAQ,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACnE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;YACnE,MAAM,MAAM,GAAG,IAAI,uBAAa,CAAC,KAAK,EAAE,wBAAwB,EAAE;gBAChE,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP,EAAE,WAAW,EAAE,aAAa,EAAE;oBAC9B,EAAE,WAAW,EAAE,aAAa,EAAE;iBAC/B;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;QACpC,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;YAClE,MAAM,MAAM,GAAG,IAAI,uBAAa,CAAC,KAAK,EAAE,wBAAwB,EAAE;gBAChE,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,gBAAgB,EAAE,mBAAmB;aACtC,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,uBAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE;gBAC3C,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,yCAAoB,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,uBAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE;gBAC1D,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;YAChE,IAAI,uBAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE;gBAC3C,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC7C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC7C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC5B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;aAChE,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,sBAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACpC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC9C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAClD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;YAC1D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,uBAAuB,EAAE;gBAC9D,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE;oBACpD,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,EAAE;oBAC1C,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,6BAA6B,EAAE;iBACjE;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;YACvD,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,0BAA0B,EAAE;gBACjE,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;aAClE,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;aAChE,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,wCAAmB,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;aAChE,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;YAC/C,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;aAChE,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YACvC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACrC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,MAAM,MAAM,GAAG,IAAI,wBAAc,CAAC,KAAK,EAAE,mBAAmB,EAAE;gBAC5D,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,KAAK,EAAE,iBAAiB;aACzB,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,wBAAc,CAAC,CAAC;YAC9C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACtC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;QACpC,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;YACnE,MAAM,MAAM,GAAG,IAAI,wBAAc,CAAC,KAAK,EAAE,yBAAyB,EAAE;gBAClE,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,gBAAgB,EAAE,mBAAmB;aACtC,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YAChE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,aAAa,EAAE,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,wBAAc,CAAC,KAAK,EAAE,mBAAmB,EAAE;gBAC7C,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,KAAK,EAAE,iBAAiB;aACzB,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,0CAAqB,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,wBAAc,CAAC,KAAK,EAAE,mBAAmB,EAAE;gBAC5D,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,KAAK,EAAE,iBAAiB;aACzB,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;YAChE,IAAI,wBAAc,CAAC,KAAK,EAAE,mBAAmB,EAAE;gBAC7C,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,KAAK,EAAE,iBAAiB;aACzB,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC7C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YACvC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,MAAM,GAAG,IAAI,qBAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE;gBACtD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAC;aAC7D,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,qBAAW,CAAC,CAAC;YAC3C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACpC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACpD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACrE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,MAAM,MAAM,GAAG,IAAI,qBAAW,CAAC,KAAK,EAAE,sBAAsB,EAAE;gBAC5D,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,mBAAmB,EAAE;oBACjD,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,mBAAmB,EAAE;iBAClD;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,qBAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE;gBACvC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAC;aAC7D,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,uCAAkB,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,qBAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE;gBACtD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAC;aAC7D,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;YAC9D,IAAI,qBAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE;gBACvC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAC;aAC7D,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;YAC3C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,MAAM,GAAG,IAAI,qBAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE;gBACtD,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,2BAA2B,EAAE,CAAC;aACpD,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,qBAAW,CAAC,CAAC;YAC3C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,2BAA2B,CAAC,CAAC;QAC5E,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,MAAM,MAAM,GAAG,IAAI,qBAAW,CAAC,KAAK,EAAE,sBAAsB,EAAE;gBAC5D,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP,EAAE,OAAO,EAAE,2BAA2B,EAAE;oBACxC,EAAE,OAAO,EAAE,2BAA2B,EAAE;iBACzC;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,qBAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE;gBACvC,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,2BAA2B,EAAE,CAAC;aACpD,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,uCAAkB,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,qBAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE;gBACtD,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,2BAA2B,EAAE,CAAC;aACpD,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;YAC9D,IAAI,qBAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE;gBACvC,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,2BAA2B,EAAE,CAAC;aACpD,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;YAC3C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC5B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,IAAI;gBACV,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC;aAC/C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,sBAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACrC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QACvE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;YAC1D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,uBAAuB,EAAE;gBAC9D,IAAI,EAAE,IAAI;gBACV,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP,EAAE,QAAQ,EAAE,qBAAqB,EAAE;oBACnC,EAAE,QAAQ,EAAE,2BAA2B,EAAE;iBAC1C;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,IAAI;gBACV,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC;aAC/C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,wCAAmB,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,IAAI;gBACV,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC;aAC/C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,IAAI;gBACV,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC;aAC/C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC5B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,SAAS,EAAE;oBACT,KAAK,EAAE,mBAAmB;iBAC3B;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,sBAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACpC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;YACjE,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,sBAAsB,EAAE;gBAC7D,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,SAAS,EAAE;oBACT,KAAK,EAAE,mBAAmB;oBAC1B,IAAI,EAAE,iBAAiB;oBACvB,YAAY,EAAE,CAAC;oBACf,WAAW,EAAE,IAAI;oBACjB,SAAS,EAAE,GAAG;oBACd,UAAU,EAAE,OAAO;oBACnB,UAAU,EAAE,GAAG;iBAChB;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;YAC5D,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACnD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACxD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,SAAS,EAAE;oBACT,KAAK,EAAE,mBAAmB;iBAC3B;aACF,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,wCAAmB,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,SAAS,EAAE;oBACT,KAAK,EAAE,mBAAmB;iBAC3B;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;YAC9D,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,SAAS,EAAE;oBACT,KAAK,EAAE,mBAAmB;oBAC1B,WAAW,EAAE,IAAI;iBAClB;aACF,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;YAC3C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YACvC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC5B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;YAC9D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP;wBACE,QAAQ,EAAE,EAAE;wBACZ,MAAM,EAAE,EAAE;wBACV,IAAI,EAAE,IAAI;wBACV,MAAM,EAAE,wBAAwB;qBACjC;iBACF;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,sBAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAClD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAChD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAChD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;YAC3D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,uBAAuB,EAAE;gBAC9D,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP;wBACE,QAAQ,EAAE,EAAE;wBACZ,MAAM,EAAE,EAAE;wBACV,IAAI,EAAE,IAAI;wBACV,MAAM,EAAE,wBAAwB;qBACjC;oBACD;wBACE,QAAQ,EAAE,EAAE;wBACZ,MAAM,EAAE,EAAE;wBACV,IAAI,EAAE,IAAI;wBACV,MAAM,EAAE,wBAAwB;qBACjC;iBACF;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP;wBACE,QAAQ,EAAE,EAAE;wBACZ,MAAM,EAAE,EAAE;wBACV,IAAI,EAAE,IAAI;wBACV,MAAM,EAAE,wBAAwB;qBACjC;iBACF;aACF,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,wCAAmB,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP;wBACE,QAAQ,EAAE,EAAE;wBACZ,MAAM,EAAE,EAAE;wBACV,IAAI,EAAE,IAAI;wBACV,MAAM,EAAE,wBAAwB;qBACjC;iBACF;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP;wBACE,QAAQ,EAAE,EAAE;wBACZ,MAAM,EAAE,EAAE;wBACV,IAAI,EAAE,IAAI;wBACV,MAAM,EAAE,wBAAwB;qBACjC;iBACF;aACF,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;YAC1C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACxC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACtC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC5B,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP,EAAE,KAAK,EAAE,CAAC,gDAAgD,CAAC,EAAE;iBAC9D;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,sBAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACpC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,SAAS,CAC7C,gDAAgD,CACjD,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;YAC1D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,uBAAuB,EAAE;gBAC9D,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP,EAAE,KAAK,EAAE,CAAC,gDAAgD,CAAC,EAAE;oBAC7D,EAAE,KAAK,EAAE,CAAC,iCAAiC,CAAC,EAAE;iBAC/C;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;YAC9D,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,uBAAuB,EAAE;gBAC9D,IAAI,EAAE,QAAQ;gBACd,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE;oBACP;wBACE,KAAK,EAAE;4BACL,WAAW;4BACX,eAAe;4BACf,8BAA8B;yBAC/B;qBACF;iBACF;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;QAC7C,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC;aACtC,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,wCAAmB,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;YACxC,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACxD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC;aACtC,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,IAAI,sBAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE;gBACzC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC;aACtC,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,6CAA6C,EAAE,GAAG,EAAE;IAC3D,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,qCAAqC,EAAE,GAAG,EAAE;QACnD,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,IAAI,oBAAU,CAAC,KAAK,EAAE,UAAU,EAAE;gBAChC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,IAAI,uBAAa,CAAC,KAAK,EAAE,aAAa,EAAE;gBACtC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,IAAI,wBAAc,CAAC,KAAK,EAAE,cAAc,EAAE;gBACxC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,KAAK,EAAE,iBAAiB;aACzB,CAAC,CAAC;YAEH,IAAI,sBAAY,CAAC,KAAK,EAAE,YAAY,EAAE;gBACpC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;aAChE,CAAC,CAAC;YAEH,IAAI,qBAAW,CAAC,KAAK,EAAE,WAAW,EAAE;gBAClC,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,sCAAiB,CAAC,CAAC;YACjD,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,yCAAoB,CAAC,CAAC;YACpD,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,0CAAqB,CAAC,CAAC;YACrD,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,wCAAmB,CAAC,CAAC;YACnD,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,uCAAkB,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,qBAAqB,EAAE,GAAG,EAAE;QACnC,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;YACzD,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACrC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;YAElC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,uCAAuC,EAAE,GAAG,EAAE;QACrD,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;YAC7D,IAAI,oBAAU,CAAC,KAAK,EAAE,eAAe,EAAE;gBACrC,IAAI,EAAE,KAAK;gBACX,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,6CAA6C;YAC7C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;YAC1C,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;YACtD,MAAM,MAAM,GAAG,IAAI,sBAAY,CAAC,KAAK,EAAE,YAAY,EAAE;gBACnD,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;aAChE,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,sBAAY,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,MAAM,MAAM,GAAG,IAAI,qBAAW,CAAC,KAAK,EAAE,WAAW,EAAE;gBACjD,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,cAAc;gBACzB,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC;aAC1C,CAAC,CAAC;YAEH,MAAM,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,qBAAW,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/**\n * Unit tests for Azure Public DNS Zone Record implementations\n *\n * This test suite validates all 10 Public DNS record types:\n * - DnsARecord\n * - DnsAaaaRecord\n * - DnsCaaRecord (Public DNS only)\n * - DnsCnameRecord\n * - DnsMxRecord\n * - DnsNsRecord (Public DNS only)\n * - DnsPtrRecord\n * - DnsSoaRecord\n * - DnsSrvRecord\n * - DnsTxtRecord\n *\n * Tests verify basic creation, correct resource types, API versions,\n * parent ID resolution, resource body structure, TTL handling,\n * record-specific properties, metadata handling, and alias record support.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport {\n  DnsARecord,\n  DnsAaaaRecord,\n  DnsCaaRecord,\n  DnsCnameRecord,\n  DnsMxRecord,\n  DnsNsRecord,\n  DnsPtrRecord,\n  DnsSoaRecord,\n  DnsSrvRecord,\n  DnsTxtRecord,\n} from \"../lib/records\";\nimport {\n  DNS_A_RECORD_TYPE,\n  DNS_AAAA_RECORD_TYPE,\n  DNS_CAA_RECORD_TYPE,\n  DNS_CNAME_RECORD_TYPE,\n  DNS_MX_RECORD_TYPE,\n  DNS_NS_RECORD_TYPE,\n  DNS_PTR_RECORD_TYPE,\n  DNS_SOA_RECORD_TYPE,\n  DNS_SRV_RECORD_TYPE,\n  DNS_TXT_RECORD_TYPE,\n} from \"../lib/records/dns-record-schemas\";\n\n// Sample DNS Zone ID for testing\nconst SAMPLE_ZONE_ID =\n  \"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg-test/providers/Microsoft.Network/dnsZones/example.com\";\n\n// Sample Public IP ID for alias record testing\nconst SAMPLE_PUBLIC_IP_ID =\n  \"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg-test/providers/Microsoft.Network/publicIPAddresses/myPublicIP\";\n\ndescribe(\"DnsARecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create an A record with required properties\", () => {\n      const record = new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      expect(record).toBeInstanceOf(DnsARecord);\n      expect(record.props.name).toBe(\"www\");\n      expect(record.props.dnsZoneId).toBe(SAMPLE_ZONE_ID);\n      expect(record.props.records).toHaveLength(1);\n      expect(record.props.records![0].ipv4Address).toBe(\"20.30.40.50\");\n    });\n\n    it(\"should create an A record with multiple IP addresses\", () => {\n      const record = new DnsARecord(stack, \"test-a-record-multi\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { ipv4Address: \"20.30.40.50\" },\n          { ipv4Address: \"20.30.40.51\" },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n\n    it(\"should create an apex A record with @ name\", () => {\n      const record = new DnsARecord(stack, \"test-a-record-apex\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      expect(record.props.name).toBe(\"@\");\n    });\n  });\n\n  describe(\"Alias Record Support\", () => {\n    it(\"should create an alias A record with targetResourceId\", () => {\n      const record = new DnsARecord(stack, \"test-a-record-alias\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        targetResourceId: SAMPLE_PUBLIC_IP_ID,\n      });\n\n      expect(record.props.targetResourceId).toBe(SAMPLE_PUBLIC_IP_ID);\n      expect(record.props.records).toBeUndefined();\n    });\n\n    it(\"should include targetResource in synthesized output for alias records\", () => {\n      new DnsARecord(stack, \"test-a-record-alias\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        targetResourceId: SAMPLE_PUBLIC_IP_ID,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"targetResource\");\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_A_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Parent ID Resolution\", () => {\n    it(\"should set parentId to the zone ID\", () => {\n      new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(SAMPLE_ZONE_ID);\n    });\n  });\n\n  describe(\"TTL Handling\", () => {\n    it(\"should use default TTL of 3600 when not specified\", () => {\n      new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"3600\");\n    });\n\n    it(\"should use custom TTL when specified\", () => {\n      new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        ttl: 300,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"300\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include ARecords in the body with PascalCase\", () => {\n      new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"ARecords\");\n      expect(synthesized).toContain(\"ipv4Address\");\n      expect(synthesized).toContain(\"20.30.40.50\");\n    });\n\n    it(\"should use TTL with uppercase in public DNS\", () => {\n      new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"TTL\");\n    });\n  });\n\n  describe(\"Metadata Handling\", () => {\n    it(\"should include metadata when provided\", () => {\n      new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n        metadata: { environment: \"production\", owner: \"team-a\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"metadata\");\n      expect(synthesized).toContain(\"environment\");\n      expect(synthesized).toContain(\"production\");\n    });\n  });\n\n  describe(\"Outputs\", () => {\n    it(\"should create required outputs\", () => {\n      const record = new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      expect(record.idOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(record.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(record.fqdnOutput).toBeInstanceOf(cdktf.TerraformOutput);\n    });\n\n    it(\"should provide fqdn property\", () => {\n      const record = new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      expect(record.fqdn).toBeDefined();\n      expect(typeof record.fqdn).toBe(\"string\");\n    });\n  });\n});\n\ndescribe(\"DnsAaaaRecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create an AAAA record with required properties\", () => {\n      const record = new DnsAaaaRecord(stack, \"test-aaaa-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      expect(record).toBeInstanceOf(DnsAaaaRecord);\n      expect(record.props.name).toBe(\"www\");\n      expect(record.props.records![0].ipv6Address).toBe(\"2001:db8::1\");\n    });\n\n    it(\"should create an AAAA record with multiple IPv6 addresses\", () => {\n      const record = new DnsAaaaRecord(stack, \"test-aaaa-record-multi\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { ipv6Address: \"2001:db8::1\" },\n          { ipv6Address: \"2001:db8::2\" },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n  });\n\n  describe(\"Alias Record Support\", () => {\n    it(\"should create an alias AAAA record with targetResourceId\", () => {\n      const record = new DnsAaaaRecord(stack, \"test-aaaa-record-alias\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        targetResourceId: SAMPLE_PUBLIC_IP_ID,\n      });\n\n      expect(record.props.targetResourceId).toBe(SAMPLE_PUBLIC_IP_ID);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsAaaaRecord(stack, \"test-aaaa-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_AAAA_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsAaaaRecord(stack, \"test-aaaa-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include AAAARecords in the body with PascalCase\", () => {\n      new DnsAaaaRecord(stack, \"test-aaaa-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"AAAARecords\");\n      expect(synthesized).toContain(\"ipv6Address\");\n      expect(synthesized).toContain(\"2001:db8::1\");\n    });\n  });\n});\n\ndescribe(\"DnsCaaRecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create a CAA record with required properties\", () => {\n      const record = new DnsCaaRecord(stack, \"test-caa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ flags: 0, tag: \"issue\", value: \"letsencrypt.org\" }],\n      });\n\n      expect(record).toBeInstanceOf(DnsCaaRecord);\n      expect(record.props.name).toBe(\"@\");\n      expect(record.props.records[0].flags).toBe(0);\n      expect(record.props.records[0].tag).toBe(\"issue\");\n      expect(record.props.records[0].value).toBe(\"letsencrypt.org\");\n    });\n\n    it(\"should create a CAA record with multiple entries\", () => {\n      const record = new DnsCaaRecord(stack, \"test-caa-record-multi\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { flags: 0, tag: \"issue\", value: \"letsencrypt.org\" },\n          { flags: 0, tag: \"issuewild\", value: \";\" },\n          { flags: 0, tag: \"iodef\", value: \"mailto:security@example.com\" },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(3);\n    });\n\n    it(\"should create a CAA record with critical flag\", () => {\n      const record = new DnsCaaRecord(stack, \"test-caa-record-critical\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ flags: 128, tag: \"issue\", value: \"letsencrypt.org\" }],\n      });\n\n      expect(record.props.records[0].flags).toBe(128);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsCaaRecord(stack, \"test-caa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ flags: 0, tag: \"issue\", value: \"letsencrypt.org\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_CAA_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsCaaRecord(stack, \"test-caa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ flags: 0, tag: \"issue\", value: \"letsencrypt.org\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include caaRecords in the body\", () => {\n      new DnsCaaRecord(stack, \"test-caa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ flags: 0, tag: \"issue\", value: \"letsencrypt.org\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"caaRecords\");\n      expect(synthesized).toContain(\"flags\");\n      expect(synthesized).toContain(\"tag\");\n      expect(synthesized).toContain(\"issue\");\n    });\n  });\n});\n\ndescribe(\"DnsCnameRecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create a CNAME record with required properties\", () => {\n      const record = new DnsCnameRecord(stack, \"test-cname-record\", {\n        name: \"app\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.example.com\",\n      });\n\n      expect(record).toBeInstanceOf(DnsCnameRecord);\n      expect(record.props.name).toBe(\"app\");\n      expect(record.props.cname).toBe(\"www.example.com\");\n    });\n  });\n\n  describe(\"Alias Record Support\", () => {\n    it(\"should create an alias CNAME record with targetResourceId\", () => {\n      const record = new DnsCnameRecord(stack, \"test-cname-record-alias\", {\n        name: \"app\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        targetResourceId: SAMPLE_PUBLIC_IP_ID,\n      });\n\n      expect(record.props.targetResourceId).toBe(SAMPLE_PUBLIC_IP_ID);\n      expect(record.props.cname).toBeUndefined();\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsCnameRecord(stack, \"test-cname-record\", {\n        name: \"app\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.example.com\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_CNAME_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsCnameRecord(stack, \"test-cname-record\", {\n        name: \"app\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.example.com\",\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include CNAMERecord in the body with PascalCase\", () => {\n      new DnsCnameRecord(stack, \"test-cname-record\", {\n        name: \"app\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.example.com\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"CNAMERecord\");\n      expect(synthesized).toContain(\"cname\");\n      expect(synthesized).toContain(\"www.example.com\");\n    });\n  });\n});\n\ndescribe(\"DnsMxRecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create an MX record with required properties\", () => {\n      const record = new DnsMxRecord(stack, \"test-mx-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ preference: 10, exchange: \"mail1.example.com\" }],\n      });\n\n      expect(record).toBeInstanceOf(DnsMxRecord);\n      expect(record.props.name).toBe(\"@\");\n      expect(record.props.records[0].preference).toBe(10);\n      expect(record.props.records[0].exchange).toBe(\"mail1.example.com\");\n    });\n\n    it(\"should create an MX record with multiple mail servers\", () => {\n      const record = new DnsMxRecord(stack, \"test-mx-record-multi\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { preference: 10, exchange: \"mail1.example.com\" },\n          { preference: 20, exchange: \"mail2.example.com\" },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsMxRecord(stack, \"test-mx-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ preference: 10, exchange: \"mail1.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_MX_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsMxRecord(stack, \"test-mx-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ preference: 10, exchange: \"mail1.example.com\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include MXRecords in the body with PascalCase\", () => {\n      new DnsMxRecord(stack, \"test-mx-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ preference: 10, exchange: \"mail1.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"MXRecords\");\n      expect(synthesized).toContain(\"preference\");\n      expect(synthesized).toContain(\"exchange\");\n    });\n  });\n});\n\ndescribe(\"DnsNsRecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create an NS record with required properties\", () => {\n      const record = new DnsNsRecord(stack, \"test-ns-record\", {\n        name: \"subdomain\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ nsdname: \"ns1.subdomain.example.com\" }],\n      });\n\n      expect(record).toBeInstanceOf(DnsNsRecord);\n      expect(record.props.name).toBe(\"subdomain\");\n      expect(record.props.records[0].nsdname).toBe(\"ns1.subdomain.example.com\");\n    });\n\n    it(\"should create an NS record with multiple name servers\", () => {\n      const record = new DnsNsRecord(stack, \"test-ns-record-multi\", {\n        name: \"subdomain\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { nsdname: \"ns1.subdomain.example.com\" },\n          { nsdname: \"ns2.subdomain.example.com\" },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsNsRecord(stack, \"test-ns-record\", {\n        name: \"subdomain\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ nsdname: \"ns1.subdomain.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_NS_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsNsRecord(stack, \"test-ns-record\", {\n        name: \"subdomain\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ nsdname: \"ns1.subdomain.example.com\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include NSRecords in the body with PascalCase\", () => {\n      new DnsNsRecord(stack, \"test-ns-record\", {\n        name: \"subdomain\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ nsdname: \"ns1.subdomain.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"NSRecords\");\n      expect(synthesized).toContain(\"nsdname\");\n    });\n  });\n});\n\ndescribe(\"DnsPtrRecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create a PTR record with required properties\", () => {\n      const record = new DnsPtrRecord(stack, \"test-ptr-record\", {\n        name: \"50\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ptrdname: \"server1.example.com\" }],\n      });\n\n      expect(record).toBeInstanceOf(DnsPtrRecord);\n      expect(record.props.name).toBe(\"50\");\n      expect(record.props.records[0].ptrdname).toBe(\"server1.example.com\");\n    });\n\n    it(\"should create a PTR record with multiple targets\", () => {\n      const record = new DnsPtrRecord(stack, \"test-ptr-record-multi\", {\n        name: \"50\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { ptrdname: \"server1.example.com\" },\n          { ptrdname: \"server1-alias.example.com\" },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsPtrRecord(stack, \"test-ptr-record\", {\n        name: \"50\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ptrdname: \"server1.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_PTR_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsPtrRecord(stack, \"test-ptr-record\", {\n        name: \"50\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ptrdname: \"server1.example.com\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include PTRRecords in the body with PascalCase\", () => {\n      new DnsPtrRecord(stack, \"test-ptr-record\", {\n        name: \"50\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ptrdname: \"server1.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"PTRRecords\");\n      expect(synthesized).toContain(\"ptrdname\");\n    });\n  });\n});\n\ndescribe(\"DnsSoaRecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create a SOA record with required properties\", () => {\n      const record = new DnsSoaRecord(stack, \"test-soa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n        },\n      });\n\n      expect(record).toBeInstanceOf(DnsSoaRecord);\n      expect(record.props.name).toBe(\"@\");\n      expect(record.props.soaRecord.email).toBe(\"admin.example.com\");\n    });\n\n    it(\"should create a SOA record with all optional properties\", () => {\n      const record = new DnsSoaRecord(stack, \"test-soa-record-full\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n          host: \"ns1.example.com\",\n          serialNumber: 1,\n          refreshTime: 3600,\n          retryTime: 300,\n          expireTime: 2419200,\n          minimumTTL: 300,\n        },\n      });\n\n      expect(record.props.soaRecord.host).toBe(\"ns1.example.com\");\n      expect(record.props.soaRecord.refreshTime).toBe(3600);\n      expect(record.props.soaRecord.retryTime).toBe(300);\n      expect(record.props.soaRecord.expireTime).toBe(2419200);\n      expect(record.props.soaRecord.minimumTTL).toBe(300);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsSoaRecord(stack, \"test-soa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_SOA_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsSoaRecord(stack, \"test-soa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n        },\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include SOARecord in the body with PascalCase\", () => {\n      new DnsSoaRecord(stack, \"test-soa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n          refreshTime: 3600,\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"SOARecord\");\n      expect(synthesized).toContain(\"email\");\n      expect(synthesized).toContain(\"refreshTime\");\n    });\n  });\n});\n\ndescribe(\"DnsSrvRecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create an SRV record with required properties\", () => {\n      const record = new DnsSrvRecord(stack, \"test-srv-record\", {\n        name: \"_sip._tcp\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.example.com\",\n          },\n        ],\n      });\n\n      expect(record).toBeInstanceOf(DnsSrvRecord);\n      expect(record.props.name).toBe(\"_sip._tcp\");\n      expect(record.props.records[0].priority).toBe(10);\n      expect(record.props.records[0].weight).toBe(60);\n      expect(record.props.records[0].port).toBe(5060);\n      expect(record.props.records[0].target).toBe(\"sipserver1.example.com\");\n    });\n\n    it(\"should create an SRV record with multiple servers\", () => {\n      const record = new DnsSrvRecord(stack, \"test-srv-record-multi\", {\n        name: \"_sip._tcp\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.example.com\",\n          },\n          {\n            priority: 10,\n            weight: 40,\n            port: 5060,\n            target: \"sipserver2.example.com\",\n          },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsSrvRecord(stack, \"test-srv-record\", {\n        name: \"_sip._tcp\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.example.com\",\n          },\n        ],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_SRV_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsSrvRecord(stack, \"test-srv-record\", {\n        name: \"_sip._tcp\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.example.com\",\n          },\n        ],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include SRVRecords in the body with PascalCase\", () => {\n      new DnsSrvRecord(stack, \"test-srv-record\", {\n        name: \"_sip._tcp\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.example.com\",\n          },\n        ],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"SRVRecords\");\n      expect(synthesized).toContain(\"priority\");\n      expect(synthesized).toContain(\"weight\");\n      expect(synthesized).toContain(\"port\");\n      expect(synthesized).toContain(\"target\");\n    });\n  });\n});\n\ndescribe(\"DnsTxtRecord\", () => {\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(\"Basic Creation\", () => {\n    it(\"should create a TXT record with required properties\", () => {\n      const record = new DnsTxtRecord(stack, \"test-txt-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { value: [\"v=spf1 include:spf.protection.outlook.com -all\"] },\n        ],\n      });\n\n      expect(record).toBeInstanceOf(DnsTxtRecord);\n      expect(record.props.name).toBe(\"@\");\n      expect(record.props.records[0].value).toContain(\n        \"v=spf1 include:spf.protection.outlook.com -all\",\n      );\n    });\n\n    it(\"should create a TXT record with multiple entries\", () => {\n      const record = new DnsTxtRecord(stack, \"test-txt-record-multi\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { value: [\"v=spf1 include:spf.protection.outlook.com -all\"] },\n          { value: [\"google-site-verification=abc123\"] },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n\n    it(\"should handle TXT record with multiple string values\", () => {\n      const record = new DnsTxtRecord(stack, \"test-txt-record-split\", {\n        name: \"_dmarc\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            value: [\n              \"v=DMARC1;\",\n              \"p=quarantine;\",\n              \"rua=mailto:dmarc@example.com\",\n            ],\n          },\n        ],\n      });\n\n      expect(record.props.records[0].value).toHaveLength(3);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new DnsTxtRecord(stack, \"test-txt-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ value: [\"v=spf1 -all\"] }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_TXT_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new DnsTxtRecord(stack, \"test-txt-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ value: [\"v=spf1 -all\"] }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2018-05-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include TXTRecords in the body with PascalCase\", () => {\n      new DnsTxtRecord(stack, \"test-txt-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ value: [\"v=spf1 -all\"] }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"TXTRecords\");\n      expect(synthesized).toContain(\"value\");\n    });\n  });\n});\n\ndescribe(\"Public DNS Records - Cross-cutting Concerns\", () => {\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(\"Multiple Record Types in Same Stack\", () => {\n    it(\"should handle multiple record types in the same stack\", () => {\n      new DnsARecord(stack, \"a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      new DnsAaaaRecord(stack, \"aaaa-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      new DnsCnameRecord(stack, \"cname-record\", {\n        name: \"app\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.example.com\",\n      });\n\n      new DnsCaaRecord(stack, \"caa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ flags: 0, tag: \"issue\", value: \"letsencrypt.org\" }],\n      });\n\n      new DnsNsRecord(stack, \"ns-record\", {\n        name: \"subdomain\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ nsdname: \"ns1.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(DNS_A_RECORD_TYPE);\n      expect(synthesized).toContain(DNS_AAAA_RECORD_TYPE);\n      expect(synthesized).toContain(DNS_CNAME_RECORD_TYPE);\n      expect(synthesized).toContain(DNS_CAA_RECORD_TYPE);\n      expect(synthesized).toContain(DNS_NS_RECORD_TYPE);\n    });\n  });\n\n  describe(\"Terraform Synthesis\", () => {\n    it(\"should synthesize valid Terraform configuration\", () => {\n      new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\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\n  describe(\"Public DNS vs Private DNS Differences\", () => {\n    it(\"should use PascalCase property names for public DNS\", () => {\n      new DnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"20.30.40.50\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      // Public DNS uses PascalCase (ARecords, TTL)\n      expect(synthesized).toContain(\"ARecords\");\n      expect(synthesized).toContain(\"TTL\");\n    });\n\n    it(\"should support CAA records (public DNS only)\", () => {\n      const record = new DnsCaaRecord(stack, \"caa-record\", {\n        name: \"@\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ flags: 0, tag: \"issue\", value: \"letsencrypt.org\" }],\n      });\n\n      expect(record).toBeInstanceOf(DnsCaaRecord);\n    });\n\n    it(\"should support NS records (public DNS only)\", () => {\n      const record = new DnsNsRecord(stack, \"ns-record\", {\n        name: \"subdomain\",\n        dnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ nsdname: \"ns1.example.com\" }],\n      });\n\n      expect(record).toBeInstanceOf(DnsNsRecord);\n    });\n  });\n});\n"]}