@microsoft/terraform-cdk-constructs 1.7.1 → 1.9.0

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

@@ -0,0 +1,924 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnsTxtRecord = exports.DnsSrvRecord = exports.DnsSoaRecord = exports.DnsPtrRecord = exports.DnsNsRecord = exports.DnsMxRecord = exports.DnsCnameRecord = exports.DnsCaaRecord = exports.DnsAaaaRecord = exports.DnsARecord = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Azure Public DNS Zone Record implementations using AzapiResource framework
+ *
+ * This file provides implementations for all Public DNS Zone record types:
+ * - DnsARecord (A records with IPv4 addresses)
+ * - DnsAaaaRecord (AAAA records with IPv6 addresses)
+ * - DnsCaaRecord (CAA records for Certificate Authority Authorization) - PUBLIC ONLY
+ * - DnsCnameRecord (CNAME records)
+ * - DnsMxRecord (MX records with exchange and preference)
+ * - DnsNsRecord (NS records for Name Servers) - PUBLIC ONLY
+ * - DnsPtrRecord (PTR records)
+ * - DnsSoaRecord (SOA records)
+ * - DnsSrvRecord (SRV records with priority, weight, port, target)
+ * - DnsTxtRecord (TXT records)
+ *
+ * API Version: 2018-05-01
+ *
+ * Key differences from Private DNS:
+ * - Property casing: Public DNS uses PascalCase (ARecords, TTL vs aRecords, ttl)
+ * - CAA records: Only available in public DNS
+ * - NS records: Only available in public DNS
+ * - targetResource: Public DNS A, AAAA, and CNAME records support alias records
+ */
+const cdktf = require("cdktf");
+const dns_record_schemas_1 = require("./dns-record-schemas");
+const azapi_resource_1 = require("../../../core-azure/lib/azapi/azapi-resource");
+/**
+ * Azure Public DNS A Record implementation
+ *
+ * A records map a hostname to one or more IPv4 addresses.
+ * Supports alias records via targetResourceId for pointing to Azure resources.
+ *
+ * @example
+ * // Create an A record with IP addresses:
+ * const aRecord = new DnsARecord(this, "web-a-record", {
+ *   name: "www",
+ *   dnsZoneId: zone.id,
+ *   ttl: 300,
+ *   records: [
+ *     { ipv4Address: "20.30.40.50" },
+ *   ],
+ * });
+ *
+ * @example
+ * // Create an alias A record pointing to an Azure resource:
+ * const aliasRecord = new DnsARecord(this, "alias-a-record", {
+ *   name: "www",
+ *   dnsZoneId: zone.id,
+ *   ttl: 300,
+ *   targetResourceId: publicIp.id,
+ * });
+ *
+ * @stability stable
+ */
+class DnsARecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the A Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the A Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the A Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_A_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+        };
+        if (typedProps.records && typedProps.records.length > 0) {
+            properties.ARecords = typedProps.records.map((r) => ({
+                ipv4Address: r.ipv4Address,
+            }));
+        }
+        if (typedProps.targetResourceId) {
+            properties.targetResource = { id: typedProps.targetResourceId };
+        }
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsARecord = DnsARecord;
+_a = JSII_RTTI_SYMBOL_1;
+DnsARecord[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsARecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_A_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_A_RECORD_VERSIONS);
+})();
+/**
+ * Azure Public DNS AAAA Record implementation
+ *
+ * AAAA records map a hostname to one or more IPv6 addresses.
+ * Supports alias records via targetResourceId for pointing to Azure resources.
+ *
+ * @example
+ * // Create an AAAA record:
+ * const aaaaRecord = new DnsAaaaRecord(this, "web-aaaa-record", {
+ *   name: "www",
+ *   dnsZoneId: zone.id,
+ *   ttl: 300,
+ *   records: [
+ *     { ipv6Address: "2001:db8::1" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class DnsAaaaRecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the AAAA Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the AAAA Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the AAAA Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_AAAA_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+        };
+        if (typedProps.records && typedProps.records.length > 0) {
+            properties.AAAARecords = typedProps.records.map((r) => ({
+                ipv6Address: r.ipv6Address,
+            }));
+        }
+        if (typedProps.targetResourceId) {
+            properties.targetResource = { id: typedProps.targetResourceId };
+        }
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsAaaaRecord = DnsAaaaRecord;
+_b = JSII_RTTI_SYMBOL_1;
+DnsAaaaRecord[_b] = { fqn: "@microsoft/terraform-cdk-constructs.DnsAaaaRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_AAAA_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_AAAA_RECORD_VERSIONS);
+})();
+/**
+ * Azure Public DNS CAA Record implementation
+ *
+ * CAA records specify which Certificate Authorities are authorized to issue
+ * certificates for a domain. This record type is only available in Public DNS Zones.
+ *
+ * @example
+ * // Create a CAA record to authorize Let's Encrypt:
+ * const caaRecord = new DnsCaaRecord(this, "caa-record", {
+ *   name: "@",
+ *   dnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { flags: 0, tag: "issue", value: "letsencrypt.org" },
+ *     { flags: 0, tag: "issuewild", value: ";" }, // Disallow wildcard certs
+ *     { flags: 0, tag: "iodef", value: "mailto:security@example.com" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class DnsCaaRecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the CAA Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the CAA Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the CAA Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_CAA_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+            caaRecords: typedProps.records.map((r) => ({
+                flags: r.flags,
+                tag: r.tag,
+                value: r.value,
+            })),
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsCaaRecord = DnsCaaRecord;
+_c = JSII_RTTI_SYMBOL_1;
+DnsCaaRecord[_c] = { fqn: "@microsoft/terraform-cdk-constructs.DnsCaaRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_CAA_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_CAA_RECORD_VERSIONS);
+})();
+/**
+ * Azure Public DNS CNAME Record implementation
+ *
+ * CNAME records create an alias from one hostname to another.
+ * Supports alias records via targetResourceId for pointing to Azure resources.
+ * Note: CNAME records cannot coexist with other record types at the same name.
+ *
+ * @example
+ * // Create a CNAME record:
+ * const cnameRecord = new DnsCnameRecord(this, "alias-record", {
+ *   name: "app",
+ *   dnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   cname: "www.example.com",
+ * });
+ *
+ * @stability stable
+ */
+class DnsCnameRecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the CNAME Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the CNAME Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the CNAME Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_CNAME_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+        };
+        if (typedProps.cname) {
+            properties.CNAMERecord = { cname: typedProps.cname };
+        }
+        if (typedProps.targetResourceId) {
+            properties.targetResource = { id: typedProps.targetResourceId };
+        }
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsCnameRecord = DnsCnameRecord;
+_d = JSII_RTTI_SYMBOL_1;
+DnsCnameRecord[_d] = { fqn: "@microsoft/terraform-cdk-constructs.DnsCnameRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_CNAME_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_CNAME_RECORD_VERSIONS);
+})();
+/**
+ * Azure Public DNS MX Record implementation
+ *
+ * MX records specify mail exchange servers for a domain.
+ *
+ * @example
+ * // Create an MX record:
+ * const mxRecord = new DnsMxRecord(this, "mail-record", {
+ *   name: "@",
+ *   dnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { preference: 10, exchange: "mail1.example.com" },
+ *     { preference: 20, exchange: "mail2.example.com" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class DnsMxRecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the MX Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the MX Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the MX Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_MX_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+            MXRecords: typedProps.records.map((r) => ({
+                preference: r.preference,
+                exchange: r.exchange,
+            })),
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsMxRecord = DnsMxRecord;
+_e = JSII_RTTI_SYMBOL_1;
+DnsMxRecord[_e] = { fqn: "@microsoft/terraform-cdk-constructs.DnsMxRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_MX_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_MX_RECORD_VERSIONS);
+})();
+/**
+ * Azure Public DNS NS Record implementation
+ *
+ * NS records specify the authoritative name servers for a domain or subdomain.
+ * This record type is only available in Public DNS Zones.
+ *
+ * @example
+ * // Create an NS record for a subdomain delegation:
+ * const nsRecord = new DnsNsRecord(this, "ns-record", {
+ *   name: "subdomain",
+ *   dnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { nsdname: "ns1.subdomain.example.com" },
+ *     { nsdname: "ns2.subdomain.example.com" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class DnsNsRecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the NS Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the NS Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the NS Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_NS_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+            NSRecords: typedProps.records.map((r) => ({
+                nsdname: r.nsdname,
+            })),
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsNsRecord = DnsNsRecord;
+_f = JSII_RTTI_SYMBOL_1;
+DnsNsRecord[_f] = { fqn: "@microsoft/terraform-cdk-constructs.DnsNsRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_NS_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_NS_RECORD_VERSIONS);
+})();
+/**
+ * Azure Public DNS PTR Record implementation
+ *
+ * PTR records are used for reverse DNS lookups, mapping IP addresses to hostnames.
+ *
+ * @example
+ * // Create a PTR record:
+ * const ptrRecord = new DnsPtrRecord(this, "ptr-record", {
+ *   name: "50",
+ *   dnsZoneId: reverseZone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { ptrdname: "server1.example.com" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class DnsPtrRecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the PTR Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the PTR Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the PTR Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_PTR_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+            PTRRecords: typedProps.records.map((r) => ({
+                ptrdname: r.ptrdname,
+            })),
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsPtrRecord = DnsPtrRecord;
+_g = JSII_RTTI_SYMBOL_1;
+DnsPtrRecord[_g] = { fqn: "@microsoft/terraform-cdk-constructs.DnsPtrRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_PTR_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_PTR_RECORD_VERSIONS);
+})();
+/**
+ * Azure Public DNS SOA Record implementation
+ *
+ * SOA records contain administrative information about a DNS zone.
+ * Note: Each zone automatically has an SOA record; this is typically used to update it.
+ *
+ * @example
+ * // Update the SOA record:
+ * const soaRecord = new DnsSoaRecord(this, "soa-record", {
+ *   name: "@",
+ *   dnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   soaRecord: {
+ *     email: "admin.example.com",
+ *     refreshTime: 3600,
+ *     retryTime: 300,
+ *     expireTime: 2419200,
+ *     minimumTTL: 300,
+ *   },
+ * });
+ *
+ * @stability stable
+ */
+class DnsSoaRecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the SOA Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the SOA Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the SOA Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_SOA_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const soaRecord = {};
+        if (typedProps.soaRecord.host !== undefined) {
+            soaRecord.host = typedProps.soaRecord.host;
+        }
+        if (typedProps.soaRecord.email !== undefined) {
+            soaRecord.email = typedProps.soaRecord.email;
+        }
+        if (typedProps.soaRecord.serialNumber !== undefined) {
+            soaRecord.serialNumber = typedProps.soaRecord.serialNumber;
+        }
+        if (typedProps.soaRecord.refreshTime !== undefined) {
+            soaRecord.refreshTime = typedProps.soaRecord.refreshTime;
+        }
+        if (typedProps.soaRecord.retryTime !== undefined) {
+            soaRecord.retryTime = typedProps.soaRecord.retryTime;
+        }
+        if (typedProps.soaRecord.expireTime !== undefined) {
+            soaRecord.expireTime = typedProps.soaRecord.expireTime;
+        }
+        if (typedProps.soaRecord.minimumTTL !== undefined) {
+            soaRecord.minimumTTL = typedProps.soaRecord.minimumTTL;
+        }
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+            SOARecord: soaRecord,
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsSoaRecord = DnsSoaRecord;
+_h = JSII_RTTI_SYMBOL_1;
+DnsSoaRecord[_h] = { fqn: "@microsoft/terraform-cdk-constructs.DnsSoaRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_SOA_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_SOA_RECORD_VERSIONS);
+})();
+/**
+ * Azure Public DNS SRV Record implementation
+ *
+ * SRV records specify the location of services like SIP, XMPP, etc.
+ *
+ * @example
+ * // Create an SRV record for a SIP service:
+ * const srvRecord = new DnsSrvRecord(this, "sip-record", {
+ *   name: "_sip._tcp",
+ *   dnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { priority: 10, weight: 60, port: 5060, target: "sipserver1.example.com" },
+ *     { priority: 10, weight: 40, port: 5060, target: "sipserver2.example.com" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class DnsSrvRecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the SRV Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the SRV Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the SRV Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_SRV_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+            SRVRecords: typedProps.records.map((r) => ({
+                priority: r.priority,
+                weight: r.weight,
+                port: r.port,
+                target: r.target,
+            })),
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsSrvRecord = DnsSrvRecord;
+_j = JSII_RTTI_SYMBOL_1;
+DnsSrvRecord[_j] = { fqn: "@microsoft/terraform-cdk-constructs.DnsSrvRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_SRV_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_SRV_RECORD_VERSIONS);
+})();
+/**
+ * Azure Public DNS TXT Record implementation
+ *
+ * TXT records store arbitrary text data, commonly used for SPF, DKIM, domain verification, etc.
+ *
+ * @example
+ * // Create a TXT record for SPF:
+ * const txtRecord = new DnsTxtRecord(this, "spf-record", {
+ *   name: "@",
+ *   dnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { value: ["v=spf1 include:spf.protection.outlook.com -all"] },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class DnsTxtRecord extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the TXT Record",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the TXT Record",
+        });
+        this.fqdnOutput = new cdktf.TerraformOutput(this, "fqdn", {
+            value: `\${${this.terraformResource.fqn}.output.properties.fqdn}`,
+            description: "The FQDN of the TXT Record",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.fqdnOutput.overrideLogicalId("fqdn");
+    }
+    resolveParentId(props) {
+        const typedProps = props;
+        return typedProps.dnsZoneId;
+    }
+    defaultVersion() {
+        return "2018-05-01";
+    }
+    resourceType() {
+        return dns_record_schemas_1.DNS_TXT_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const properties = {
+            TTL: typedProps.ttl ?? 3600,
+            TXTRecords: typedProps.records.map((r) => ({
+                value: r.value,
+            })),
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            properties.metadata = typedProps.metadata;
+        }
+        return { properties };
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.DnsTxtRecord = DnsTxtRecord;
+_k = JSII_RTTI_SYMBOL_1;
+DnsTxtRecord[_k] = { fqn: "@microsoft/terraform-cdk-constructs.DnsTxtRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(dns_record_schemas_1.DNS_TXT_RECORD_TYPE, dns_record_schemas_1.ALL_DNS_TXT_RECORD_VERSIONS);
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dns-records.js","sourceRoot":"","sources":["../../../../src/azure-dnszone/lib/records/dns-records.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Azure Public DNS Zone Record implementations using AzapiResource framework\n *\n * This file provides implementations for all Public DNS Zone record types:\n * - DnsARecord (A records with IPv4 addresses)\n * - DnsAaaaRecord (AAAA records with IPv6 addresses)\n * - DnsCaaRecord (CAA records for Certificate Authority Authorization) - PUBLIC ONLY\n * - DnsCnameRecord (CNAME records)\n * - DnsMxRecord (MX records with exchange and preference)\n * - DnsNsRecord (NS records for Name Servers) - PUBLIC ONLY\n * - DnsPtrRecord (PTR records)\n * - DnsSoaRecord (SOA records)\n * - DnsSrvRecord (SRV records with priority, weight, port, target)\n * - DnsTxtRecord (TXT records)\n *\n * API Version: 2018-05-01\n *\n * Key differences from Private DNS:\n * - Property casing: Public DNS uses PascalCase (ARecords, TTL vs aRecords, ttl)\n * - CAA records: Only available in public DNS\n * - NS records: Only available in public DNS\n * - targetResource: Public DNS A, AAAA, and CNAME records support alias records\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_DNS_A_RECORD_VERSIONS,\n  ALL_DNS_AAAA_RECORD_VERSIONS,\n  ALL_DNS_CAA_RECORD_VERSIONS,\n  ALL_DNS_CNAME_RECORD_VERSIONS,\n  ALL_DNS_MX_RECORD_VERSIONS,\n  ALL_DNS_NS_RECORD_VERSIONS,\n  ALL_DNS_PTR_RECORD_VERSIONS,\n  ALL_DNS_SOA_RECORD_VERSIONS,\n  ALL_DNS_SRV_RECORD_VERSIONS,\n  ALL_DNS_TXT_RECORD_VERSIONS,\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 \"./dns-record-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n} from \"../../../core-azure/lib/azapi/azapi-resource\";\nimport { ApiSchema } from \"../../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n// =============================================================================\n// COMMON INTERFACES\n// =============================================================================\n\n/**\n * Base properties shared by all Public DNS record types\n *\n * Note: The `name` property is inherited from AzapiResourceProps.\n * For DNS records, use @ for apex records or provide a relative name like \"www\" or \"mail\".\n */\nexport interface DnsRecordBaseProps extends AzapiResourceProps {\n  /**\n   * Resource ID of the parent DNS Zone\n   * @example zone.id or \"/subscriptions/.../providers/Microsoft.Network/dnsZones/example.com\"\n   */\n  readonly dnsZoneId: string;\n\n  /**\n   * Time to Live in seconds\n   * @default 3600\n   */\n  readonly ttl?: number;\n\n  /**\n   * Metadata key-value pairs for the record set\n   */\n  readonly metadata?: { [key: string]: string };\n}\n\n// =============================================================================\n// A RECORD\n// =============================================================================\n\n/**\n * Entry for an A record with IPv4 address\n */\nexport interface DnsARecordEntry {\n  /**\n   * The IPv4 address of this A record\n   * @example \"20.30.40.50\"\n   */\n  readonly ipv4Address: string;\n}\n\n/**\n * Properties for Public DNS A Record\n */\nexport interface DnsARecordProps extends DnsRecordBaseProps {\n  /**\n   * Array of A records with IPv4 addresses\n   * Either records or targetResourceId must be specified\n   */\n  readonly records?: DnsARecordEntry[];\n\n  /**\n   * Reference to an Azure resource from where the IP content is taken (alias record)\n   * Either records or targetResourceId must be specified\n   * @example publicIp.id\n   */\n  readonly targetResourceId?: string;\n}\n\n/**\n * Azure Public DNS A Record implementation\n *\n * A records map a hostname to one or more IPv4 addresses.\n * Supports alias records via targetResourceId for pointing to Azure resources.\n *\n * @example\n * // Create an A record with IP addresses:\n * const aRecord = new DnsARecord(this, \"web-a-record\", {\n *   name: \"www\",\n *   dnsZoneId: zone.id,\n *   ttl: 300,\n *   records: [\n *     { ipv4Address: \"20.30.40.50\" },\n *   ],\n * });\n *\n * @example\n * // Create an alias A record pointing to an Azure resource:\n * const aliasRecord = new DnsARecord(this, \"alias-a-record\", {\n *   name: \"www\",\n *   dnsZoneId: zone.id,\n *   ttl: 300,\n *   targetResourceId: publicIp.id,\n * });\n *\n * @stability stable\n */\nexport class DnsARecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(DNS_A_RECORD_TYPE, ALL_DNS_A_RECORD_VERSIONS);\n  }\n\n  public readonly props: DnsARecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsARecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the A Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the A Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the A Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsARecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_A_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsARecordProps;\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n    };\n\n    if (typedProps.records && typedProps.records.length > 0) {\n      properties.ARecords = typedProps.records.map((r) => ({\n        ipv4Address: r.ipv4Address,\n      }));\n    }\n\n    if (typedProps.targetResourceId) {\n      properties.targetResource = { id: typedProps.targetResourceId };\n    }\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n\n// =============================================================================\n// AAAA RECORD\n// =============================================================================\n\n/**\n * Entry for an AAAA record with IPv6 address\n */\nexport interface DnsAaaaRecordEntry {\n  /**\n   * The IPv6 address of this AAAA record\n   * @example \"2001:db8::1\"\n   */\n  readonly ipv6Address: string;\n}\n\n/**\n * Properties for Public DNS AAAA Record\n */\nexport interface DnsAaaaRecordProps extends DnsRecordBaseProps {\n  /**\n   * Array of AAAA records with IPv6 addresses\n   * Either records or targetResourceId must be specified\n   */\n  readonly records?: DnsAaaaRecordEntry[];\n\n  /**\n   * Reference to an Azure resource from where the IP content is taken (alias record)\n   * Either records or targetResourceId must be specified\n   */\n  readonly targetResourceId?: string;\n}\n\n/**\n * Azure Public DNS AAAA Record implementation\n *\n * AAAA records map a hostname to one or more IPv6 addresses.\n * Supports alias records via targetResourceId for pointing to Azure resources.\n *\n * @example\n * // Create an AAAA record:\n * const aaaaRecord = new DnsAaaaRecord(this, \"web-aaaa-record\", {\n *   name: \"www\",\n *   dnsZoneId: zone.id,\n *   ttl: 300,\n *   records: [\n *     { ipv6Address: \"2001:db8::1\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class DnsAaaaRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      DNS_AAAA_RECORD_TYPE,\n      ALL_DNS_AAAA_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: DnsAaaaRecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsAaaaRecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the AAAA Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the AAAA Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the AAAA Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsAaaaRecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_AAAA_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsAaaaRecordProps;\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n    };\n\n    if (typedProps.records && typedProps.records.length > 0) {\n      properties.AAAARecords = typedProps.records.map((r) => ({\n        ipv6Address: r.ipv6Address,\n      }));\n    }\n\n    if (typedProps.targetResourceId) {\n      properties.targetResource = { id: typedProps.targetResourceId };\n    }\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n\n// =============================================================================\n// CAA RECORD (PUBLIC DNS ONLY)\n// =============================================================================\n\n/**\n * Entry for a CAA record (Certificate Authority Authorization)\n */\nexport interface DnsCaaRecordEntry {\n  /**\n   * Flags for this CAA record (0-255)\n   * 0 = non-critical, 128 = critical\n   * @example 0\n   */\n  readonly flags: number;\n\n  /**\n   * The property tag for this CAA record\n   * Common values: \"issue\", \"issuewild\", \"iodef\"\n   * @example \"issue\"\n   */\n  readonly tag: string;\n\n  /**\n   * The value associated with the tag\n   * @example \"letsencrypt.org\"\n   */\n  readonly value: string;\n}\n\n/**\n * Properties for Public DNS CAA Record\n */\nexport interface DnsCaaRecordProps extends DnsRecordBaseProps {\n  /**\n   * Array of CAA records with flags, tag, and value\n   */\n  readonly records: DnsCaaRecordEntry[];\n}\n\n/**\n * Azure Public DNS CAA Record implementation\n *\n * CAA records specify which Certificate Authorities are authorized to issue\n * certificates for a domain. This record type is only available in Public DNS Zones.\n *\n * @example\n * // Create a CAA record to authorize Let's Encrypt:\n * const caaRecord = new DnsCaaRecord(this, \"caa-record\", {\n *   name: \"@\",\n *   dnsZoneId: zone.id,\n *   ttl: 3600,\n *   records: [\n *     { flags: 0, tag: \"issue\", value: \"letsencrypt.org\" },\n *     { flags: 0, tag: \"issuewild\", value: \";\" }, // Disallow wildcard certs\n *     { flags: 0, tag: \"iodef\", value: \"mailto:security@example.com\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class DnsCaaRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      DNS_CAA_RECORD_TYPE,\n      ALL_DNS_CAA_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: DnsCaaRecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsCaaRecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the CAA Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the CAA Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the CAA Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsCaaRecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_CAA_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsCaaRecordProps;\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n      caaRecords: typedProps.records.map((r) => ({\n        flags: r.flags,\n        tag: r.tag,\n        value: r.value,\n      })),\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n\n// =============================================================================\n// CNAME RECORD\n// =============================================================================\n\n/**\n * Properties for Public DNS CNAME Record\n */\nexport interface DnsCnameRecordProps extends DnsRecordBaseProps {\n  /**\n   * The canonical name for this CNAME record\n   * Either cname or targetResourceId must be specified\n   * @example \"www.contoso.com\"\n   */\n  readonly cname?: string;\n\n  /**\n   * Reference to an Azure resource from where the DNS content is taken (alias record)\n   * Either cname or targetResourceId must be specified\n   */\n  readonly targetResourceId?: string;\n}\n\n/**\n * Azure Public DNS CNAME Record implementation\n *\n * CNAME records create an alias from one hostname to another.\n * Supports alias records via targetResourceId for pointing to Azure resources.\n * Note: CNAME records cannot coexist with other record types at the same name.\n *\n * @example\n * // Create a CNAME record:\n * const cnameRecord = new DnsCnameRecord(this, \"alias-record\", {\n *   name: \"app\",\n *   dnsZoneId: zone.id,\n *   ttl: 3600,\n *   cname: \"www.example.com\",\n * });\n *\n * @stability stable\n */\nexport class DnsCnameRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      DNS_CNAME_RECORD_TYPE,\n      ALL_DNS_CNAME_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: DnsCnameRecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsCnameRecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the CNAME Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the CNAME Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the CNAME Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsCnameRecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_CNAME_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsCnameRecordProps;\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n    };\n\n    if (typedProps.cname) {\n      properties.CNAMERecord = { cname: typedProps.cname };\n    }\n\n    if (typedProps.targetResourceId) {\n      properties.targetResource = { id: typedProps.targetResourceId };\n    }\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n\n// =============================================================================\n// MX RECORD\n// =============================================================================\n\n/**\n * Entry for an MX record\n */\nexport interface DnsMxRecordEntry {\n  /**\n   * The preference value for this MX record (lower values have higher priority)\n   * @example 10\n   */\n  readonly preference: number;\n\n  /**\n   * The mail exchange server hostname\n   * @example \"mail1.example.com\"\n   */\n  readonly exchange: string;\n}\n\n/**\n * Properties for Public DNS MX Record\n */\nexport interface DnsMxRecordProps extends DnsRecordBaseProps {\n  /**\n   * Array of MX records with exchange and preference\n   */\n  readonly records: DnsMxRecordEntry[];\n}\n\n/**\n * Azure Public DNS MX Record implementation\n *\n * MX records specify mail exchange servers for a domain.\n *\n * @example\n * // Create an MX record:\n * const mxRecord = new DnsMxRecord(this, \"mail-record\", {\n *   name: \"@\",\n *   dnsZoneId: zone.id,\n *   ttl: 3600,\n *   records: [\n *     { preference: 10, exchange: \"mail1.example.com\" },\n *     { preference: 20, exchange: \"mail2.example.com\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class DnsMxRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      DNS_MX_RECORD_TYPE,\n      ALL_DNS_MX_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: DnsMxRecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsMxRecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the MX Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the MX Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the MX Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsMxRecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_MX_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsMxRecordProps;\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n      MXRecords: typedProps.records.map((r) => ({\n        preference: r.preference,\n        exchange: r.exchange,\n      })),\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n\n// =============================================================================\n// NS RECORD (PUBLIC DNS ONLY)\n// =============================================================================\n\n/**\n * Entry for an NS record\n */\nexport interface DnsNsRecordEntry {\n  /**\n   * The name server domain name\n   * @example \"ns1.example.com\"\n   */\n  readonly nsdname: string;\n}\n\n/**\n * Properties for Public DNS NS Record\n */\nexport interface DnsNsRecordProps extends DnsRecordBaseProps {\n  /**\n   * Array of NS records with nsdname values\n   */\n  readonly records: DnsNsRecordEntry[];\n}\n\n/**\n * Azure Public DNS NS Record implementation\n *\n * NS records specify the authoritative name servers for a domain or subdomain.\n * This record type is only available in Public DNS Zones.\n *\n * @example\n * // Create an NS record for a subdomain delegation:\n * const nsRecord = new DnsNsRecord(this, \"ns-record\", {\n *   name: \"subdomain\",\n *   dnsZoneId: zone.id,\n *   ttl: 3600,\n *   records: [\n *     { nsdname: \"ns1.subdomain.example.com\" },\n *     { nsdname: \"ns2.subdomain.example.com\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class DnsNsRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      DNS_NS_RECORD_TYPE,\n      ALL_DNS_NS_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: DnsNsRecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsNsRecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the NS Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the NS Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the NS Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsNsRecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_NS_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsNsRecordProps;\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n      NSRecords: typedProps.records.map((r) => ({\n        nsdname: r.nsdname,\n      })),\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n\n// =============================================================================\n// PTR RECORD\n// =============================================================================\n\n/**\n * Entry for a PTR record\n */\nexport interface DnsPtrRecordEntry {\n  /**\n   * The PTR target domain name\n   * @example \"server1.example.com\"\n   */\n  readonly ptrdname: string;\n}\n\n/**\n * Properties for Public DNS PTR Record\n */\nexport interface DnsPtrRecordProps extends DnsRecordBaseProps {\n  /**\n   * Array of PTR records with ptrdname values\n   */\n  readonly records: DnsPtrRecordEntry[];\n}\n\n/**\n * Azure Public DNS PTR Record implementation\n *\n * PTR records are used for reverse DNS lookups, mapping IP addresses to hostnames.\n *\n * @example\n * // Create a PTR record:\n * const ptrRecord = new DnsPtrRecord(this, \"ptr-record\", {\n *   name: \"50\",\n *   dnsZoneId: reverseZone.id,\n *   ttl: 3600,\n *   records: [\n *     { ptrdname: \"server1.example.com\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class DnsPtrRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      DNS_PTR_RECORD_TYPE,\n      ALL_DNS_PTR_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: DnsPtrRecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsPtrRecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the PTR Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the PTR Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the PTR Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsPtrRecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_PTR_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsPtrRecordProps;\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n      PTRRecords: typedProps.records.map((r) => ({\n        ptrdname: r.ptrdname,\n      })),\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n\n// =============================================================================\n// SOA RECORD\n// =============================================================================\n\n/**\n * SOA record configuration\n */\nexport interface DnsSoaRecordConfig {\n  /**\n   * The domain name of the authoritative name server\n   */\n  readonly host?: string;\n\n  /**\n   * The email contact for this zone (with @ replaced by .)\n   * @example \"admin.example.com\" (for admin@example.com)\n   */\n  readonly email?: string;\n\n  /**\n   * The serial number for this zone\n   */\n  readonly serialNumber?: number;\n\n  /**\n   * The refresh time in seconds\n   */\n  readonly refreshTime?: number;\n\n  /**\n   * The retry time in seconds\n   */\n  readonly retryTime?: number;\n\n  /**\n   * The expire time in seconds\n   */\n  readonly expireTime?: number;\n\n  /**\n   * The minimum TTL in seconds\n   */\n  readonly minimumTTL?: number;\n}\n\n/**\n * Properties for Public DNS SOA Record\n */\nexport interface DnsSoaRecordProps extends DnsRecordBaseProps {\n  /**\n   * SOA record configuration\n   */\n  readonly soaRecord: DnsSoaRecordConfig;\n}\n\n/**\n * Azure Public DNS SOA Record implementation\n *\n * SOA records contain administrative information about a DNS zone.\n * Note: Each zone automatically has an SOA record; this is typically used to update it.\n *\n * @example\n * // Update the SOA record:\n * const soaRecord = new DnsSoaRecord(this, \"soa-record\", {\n *   name: \"@\",\n *   dnsZoneId: zone.id,\n *   ttl: 3600,\n *   soaRecord: {\n *     email: \"admin.example.com\",\n *     refreshTime: 3600,\n *     retryTime: 300,\n *     expireTime: 2419200,\n *     minimumTTL: 300,\n *   },\n * });\n *\n * @stability stable\n */\nexport class DnsSoaRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      DNS_SOA_RECORD_TYPE,\n      ALL_DNS_SOA_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: DnsSoaRecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsSoaRecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the SOA Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the SOA Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the SOA Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsSoaRecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_SOA_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsSoaRecordProps;\n    const soaRecord: { [key: string]: unknown } = {};\n\n    if (typedProps.soaRecord.host !== undefined) {\n      soaRecord.host = typedProps.soaRecord.host;\n    }\n    if (typedProps.soaRecord.email !== undefined) {\n      soaRecord.email = typedProps.soaRecord.email;\n    }\n    if (typedProps.soaRecord.serialNumber !== undefined) {\n      soaRecord.serialNumber = typedProps.soaRecord.serialNumber;\n    }\n    if (typedProps.soaRecord.refreshTime !== undefined) {\n      soaRecord.refreshTime = typedProps.soaRecord.refreshTime;\n    }\n    if (typedProps.soaRecord.retryTime !== undefined) {\n      soaRecord.retryTime = typedProps.soaRecord.retryTime;\n    }\n    if (typedProps.soaRecord.expireTime !== undefined) {\n      soaRecord.expireTime = typedProps.soaRecord.expireTime;\n    }\n    if (typedProps.soaRecord.minimumTTL !== undefined) {\n      soaRecord.minimumTTL = typedProps.soaRecord.minimumTTL;\n    }\n\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n      SOARecord: soaRecord,\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n\n// =============================================================================\n// SRV RECORD\n// =============================================================================\n\n/**\n * Entry for an SRV record\n */\nexport interface DnsSrvRecordEntry {\n  /**\n   * The priority of this SRV record (lower values have higher priority)\n   */\n  readonly priority: number;\n\n  /**\n   * The weight of this SRV record (used for load balancing among records with same priority)\n   */\n  readonly weight: number;\n\n  /**\n   * The port number for the service\n   */\n  readonly port: number;\n\n  /**\n   * The target hostname providing the service\n   * @example \"sipserver.example.com\"\n   */\n  readonly target: string;\n}\n\n/**\n * Properties for Public DNS SRV Record\n */\nexport interface DnsSrvRecordProps extends DnsRecordBaseProps {\n  /**\n   * Array of SRV records with priority, weight, port, and target\n   */\n  readonly records: DnsSrvRecordEntry[];\n}\n\n/**\n * Azure Public DNS SRV Record implementation\n *\n * SRV records specify the location of services like SIP, XMPP, etc.\n *\n * @example\n * // Create an SRV record for a SIP service:\n * const srvRecord = new DnsSrvRecord(this, \"sip-record\", {\n *   name: \"_sip._tcp\",\n *   dnsZoneId: zone.id,\n *   ttl: 3600,\n *   records: [\n *     { priority: 10, weight: 60, port: 5060, target: \"sipserver1.example.com\" },\n *     { priority: 10, weight: 40, port: 5060, target: \"sipserver2.example.com\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class DnsSrvRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      DNS_SRV_RECORD_TYPE,\n      ALL_DNS_SRV_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: DnsSrvRecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsSrvRecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the SRV Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the SRV Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the SRV Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsSrvRecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_SRV_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsSrvRecordProps;\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n      SRVRecords: typedProps.records.map((r) => ({\n        priority: r.priority,\n        weight: r.weight,\n        port: r.port,\n        target: r.target,\n      })),\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n\n// =============================================================================\n// TXT RECORD\n// =============================================================================\n\n/**\n * Entry for a TXT record\n */\nexport interface DnsTxtRecordEntry {\n  /**\n   * The text value of this TXT record (array of strings, each up to 255 chars)\n   * Long values are automatically split into multiple strings\n   * @example [\"v=spf1 include:spf.protection.outlook.com -all\"]\n   */\n  readonly value: string[];\n}\n\n/**\n * Properties for Public DNS TXT Record\n */\nexport interface DnsTxtRecordProps extends DnsRecordBaseProps {\n  /**\n   * Array of TXT records with string values\n   */\n  readonly records: DnsTxtRecordEntry[];\n}\n\n/**\n * Azure Public DNS TXT Record implementation\n *\n * TXT records store arbitrary text data, commonly used for SPF, DKIM, domain verification, etc.\n *\n * @example\n * // Create a TXT record for SPF:\n * const txtRecord = new DnsTxtRecord(this, \"spf-record\", {\n *   name: \"@\",\n *   dnsZoneId: zone.id,\n *   ttl: 3600,\n *   records: [\n *     { value: [\"v=spf1 include:spf.protection.outlook.com -all\"] },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class DnsTxtRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      DNS_TXT_RECORD_TYPE,\n      ALL_DNS_TXT_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: DnsTxtRecordProps;\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n  public readonly fqdnOutput: cdktf.TerraformOutput;\n\n  constructor(scope: Construct, id: string, props: DnsTxtRecordProps) {\n    super(scope, id, props);\n    this.props = props;\n\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the TXT Record\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the TXT Record\",\n    });\n\n    this.fqdnOutput = new cdktf.TerraformOutput(this, \"fqdn\", {\n      value: `\\${${this.terraformResource.fqn}.output.properties.fqdn}`,\n      description: \"The FQDN of the TXT Record\",\n    });\n\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.fqdnOutput.overrideLogicalId(\"fqdn\");\n  }\n\n  protected resolveParentId(props: any): string {\n    const typedProps = props as DnsTxtRecordProps;\n    return typedProps.dnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2018-05-01\";\n  }\n\n  protected resourceType(): string {\n    return DNS_TXT_RECORD_TYPE;\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected requiresLocation(): boolean {\n    return false;\n  }\n\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  protected createResourceBody(props: any): any {\n    const typedProps = props as DnsTxtRecordProps;\n    const properties: { [key: string]: unknown } = {\n      TTL: typedProps.ttl ?? 3600,\n      TXTRecords: typedProps.records.map((r) => ({\n        value: r.value,\n      })),\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      properties.metadata = typedProps.metadata;\n    }\n\n    return { properties };\n  }\n\n  /**\n   * Get the FQDN of the record\n   */\n  public get fqdn(): string {\n    return `\\${${this.terraformResource.fqn}.output.properties.fqdn}`;\n  }\n}\n"]}