@microsoft/terraform-cdk-constructs 1.7.1 → 1.9.0

package/lib/azure-privatednszone/lib/records/private-dns-records.js

@@ -0,0 +1,739 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f, _g, _h;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateDnsTxtRecord = exports.PrivateDnsSrvRecord = exports.PrivateDnsSoaRecord = exports.PrivateDnsPtrRecord = exports.PrivateDnsMxRecord = exports.PrivateDnsCnameRecord = exports.PrivateDnsAaaaRecord = exports.PrivateDnsARecord = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Azure Private DNS Zone Record implementations using AzapiResource framework
+ *
+ * This file provides implementations for all Private DNS Zone record types:
+ * - PrivateDnsARecord (A records with IPv4 addresses)
+ * - PrivateDnsAaaaRecord (AAAA records with IPv6 addresses)
+ * - PrivateDnsCnameRecord (CNAME records)
+ * - PrivateDnsMxRecord (MX records with exchange and preference)
+ * - PrivateDnsPtrRecord (PTR records)
+ * - PrivateDnsSoaRecord (SOA records)
+ * - PrivateDnsSrvRecord (SRV records with priority, weight, port, target)
+ * - PrivateDnsTxtRecord (TXT records)
+ *
+ * API Version: 2024-06-01
+ */
+const cdktf = require("cdktf");
+const private_dns_record_schemas_1 = require("./private-dns-record-schemas");
+const azapi_resource_1 = require("../../../core-azure/lib/azapi/azapi-resource");
+/**
+ * Azure Private DNS A Record implementation
+ *
+ * A records map a hostname to one or more IPv4 addresses.
+ *
+ * @example
+ * // Create an A record with multiple IP addresses:
+ * const aRecord = new PrivateDnsARecord(this, "web-a-record", {
+ *   name: "www",
+ *   privateDnsZoneId: zone.id,
+ *   ttl: 300,
+ *   records: [
+ *     { ipv4Address: "10.0.1.4" },
+ *     { ipv4Address: "10.0.1.5" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class PrivateDnsARecord 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.privateDnsZoneId;
+    }
+    defaultVersion() {
+        return "2024-06-01";
+    }
+    resourceType() {
+        return private_dns_record_schemas_1.PRIVATE_DNS_A_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const body = {
+            properties: {
+                ttl: typedProps.ttl ?? 3600,
+                aRecords: typedProps.records.map((r) => ({
+                    ipv4Address: r.ipv4Address,
+                })),
+            },
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            body.properties.metadata =
+                typedProps.metadata;
+        }
+        return body;
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.PrivateDnsARecord = PrivateDnsARecord;
+_a = JSII_RTTI_SYMBOL_1;
+PrivateDnsARecord[_a] = { fqn: "@microsoft/terraform-cdk-constructs.PrivateDnsARecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(private_dns_record_schemas_1.PRIVATE_DNS_A_RECORD_TYPE, private_dns_record_schemas_1.ALL_PRIVATE_DNS_A_RECORD_VERSIONS);
+})();
+/**
+ * Azure Private DNS AAAA Record implementation
+ *
+ * AAAA records map a hostname to one or more IPv6 addresses.
+ *
+ * @example
+ * // Create an AAAA record:
+ * const aaaaRecord = new PrivateDnsAaaaRecord(this, "web-aaaa-record", {
+ *   name: "www",
+ *   privateDnsZoneId: zone.id,
+ *   ttl: 300,
+ *   records: [
+ *     { ipv6Address: "2001:db8::1" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class PrivateDnsAaaaRecord 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.privateDnsZoneId;
+    }
+    defaultVersion() {
+        return "2024-06-01";
+    }
+    resourceType() {
+        return private_dns_record_schemas_1.PRIVATE_DNS_AAAA_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const body = {
+            properties: {
+                ttl: typedProps.ttl ?? 3600,
+                aaaaRecords: typedProps.records.map((r) => ({
+                    ipv6Address: r.ipv6Address,
+                })),
+            },
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            body.properties.metadata =
+                typedProps.metadata;
+        }
+        return body;
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.PrivateDnsAaaaRecord = PrivateDnsAaaaRecord;
+_b = JSII_RTTI_SYMBOL_1;
+PrivateDnsAaaaRecord[_b] = { fqn: "@microsoft/terraform-cdk-constructs.PrivateDnsAaaaRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(private_dns_record_schemas_1.PRIVATE_DNS_AAAA_RECORD_TYPE, private_dns_record_schemas_1.ALL_PRIVATE_DNS_AAAA_RECORD_VERSIONS);
+})();
+/**
+ * Azure Private DNS CNAME Record implementation
+ *
+ * CNAME records create an alias from one hostname to another.
+ * Note: CNAME records cannot coexist with other record types at the same name.
+ *
+ * @example
+ * // Create a CNAME record:
+ * const cnameRecord = new PrivateDnsCnameRecord(this, "alias-record", {
+ *   name: "app",
+ *   privateDnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   cname: "www.internal.example.com",
+ * });
+ *
+ * @stability stable
+ */
+class PrivateDnsCnameRecord 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.privateDnsZoneId;
+    }
+    defaultVersion() {
+        return "2024-06-01";
+    }
+    resourceType() {
+        return private_dns_record_schemas_1.PRIVATE_DNS_CNAME_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const body = {
+            properties: {
+                ttl: typedProps.ttl ?? 3600,
+                cnameRecord: {
+                    cname: typedProps.cname,
+                },
+            },
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            body.properties.metadata =
+                typedProps.metadata;
+        }
+        return body;
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.PrivateDnsCnameRecord = PrivateDnsCnameRecord;
+_c = JSII_RTTI_SYMBOL_1;
+PrivateDnsCnameRecord[_c] = { fqn: "@microsoft/terraform-cdk-constructs.PrivateDnsCnameRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(private_dns_record_schemas_1.PRIVATE_DNS_CNAME_RECORD_TYPE, private_dns_record_schemas_1.ALL_PRIVATE_DNS_CNAME_RECORD_VERSIONS);
+})();
+/**
+ * Azure Private DNS MX Record implementation
+ *
+ * MX records specify mail exchange servers for a domain.
+ *
+ * @example
+ * // Create an MX record:
+ * const mxRecord = new PrivateDnsMxRecord(this, "mail-record", {
+ *   name: "@",
+ *   privateDnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { preference: 10, exchange: "mail1.internal.example.com" },
+ *     { preference: 20, exchange: "mail2.internal.example.com" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class PrivateDnsMxRecord 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.privateDnsZoneId;
+    }
+    defaultVersion() {
+        return "2024-06-01";
+    }
+    resourceType() {
+        return private_dns_record_schemas_1.PRIVATE_DNS_MX_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const body = {
+            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) {
+            body.properties.metadata =
+                typedProps.metadata;
+        }
+        return body;
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.PrivateDnsMxRecord = PrivateDnsMxRecord;
+_d = JSII_RTTI_SYMBOL_1;
+PrivateDnsMxRecord[_d] = { fqn: "@microsoft/terraform-cdk-constructs.PrivateDnsMxRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(private_dns_record_schemas_1.PRIVATE_DNS_MX_RECORD_TYPE, private_dns_record_schemas_1.ALL_PRIVATE_DNS_MX_RECORD_VERSIONS);
+})();
+/**
+ * Azure Private 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 PrivateDnsPtrRecord(this, "ptr-record", {
+ *   name: "4.1.0.10.in-addr.arpa",
+ *   privateDnsZoneId: reverseZone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { ptrdname: "server1.internal.example.com" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class PrivateDnsPtrRecord 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.privateDnsZoneId;
+    }
+    defaultVersion() {
+        return "2024-06-01";
+    }
+    resourceType() {
+        return private_dns_record_schemas_1.PRIVATE_DNS_PTR_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const body = {
+            properties: {
+                ttl: typedProps.ttl ?? 3600,
+                ptrRecords: typedProps.records.map((r) => ({ ptrdname: r.ptrdname })),
+            },
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            body.properties.metadata =
+                typedProps.metadata;
+        }
+        return body;
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.PrivateDnsPtrRecord = PrivateDnsPtrRecord;
+_e = JSII_RTTI_SYMBOL_1;
+PrivateDnsPtrRecord[_e] = { fqn: "@microsoft/terraform-cdk-constructs.PrivateDnsPtrRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(private_dns_record_schemas_1.PRIVATE_DNS_PTR_RECORD_TYPE, private_dns_record_schemas_1.ALL_PRIVATE_DNS_PTR_RECORD_VERSIONS);
+})();
+/**
+ * Azure Private 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 PrivateDnsSoaRecord(this, "soa-record", {
+ *   name: "@",
+ *   privateDnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   soaRecord: {
+ *     email: "admin.example.com",
+ *     refreshTime: 3600,
+ *     retryTime: 300,
+ *     expireTime: 2419200,
+ *     minimumTtl: 300,
+ *   },
+ * });
+ *
+ * @stability stable
+ */
+class PrivateDnsSoaRecord 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.privateDnsZoneId;
+    }
+    defaultVersion() {
+        return "2024-06-01";
+    }
+    resourceType() {
+        return private_dns_record_schemas_1.PRIVATE_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 body = {
+            properties: {
+                ttl: typedProps.ttl ?? 3600,
+                soaRecord: soaRecord,
+            },
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            body.properties.metadata =
+                typedProps.metadata;
+        }
+        return body;
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.PrivateDnsSoaRecord = PrivateDnsSoaRecord;
+_f = JSII_RTTI_SYMBOL_1;
+PrivateDnsSoaRecord[_f] = { fqn: "@microsoft/terraform-cdk-constructs.PrivateDnsSoaRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(private_dns_record_schemas_1.PRIVATE_DNS_SOA_RECORD_TYPE, private_dns_record_schemas_1.ALL_PRIVATE_DNS_SOA_RECORD_VERSIONS);
+})();
+/**
+ * Azure Private 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 PrivateDnsSrvRecord(this, "sip-record", {
+ *   name: "_sip._tcp",
+ *   privateDnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { priority: 10, weight: 60, port: 5060, target: "sipserver1.internal.example.com" },
+ *     { priority: 10, weight: 40, port: 5060, target: "sipserver2.internal.example.com" },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class PrivateDnsSrvRecord 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.privateDnsZoneId;
+    }
+    defaultVersion() {
+        return "2024-06-01";
+    }
+    resourceType() {
+        return private_dns_record_schemas_1.PRIVATE_DNS_SRV_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const body = {
+            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) {
+            body.properties.metadata =
+                typedProps.metadata;
+        }
+        return body;
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.PrivateDnsSrvRecord = PrivateDnsSrvRecord;
+_g = JSII_RTTI_SYMBOL_1;
+PrivateDnsSrvRecord[_g] = { fqn: "@microsoft/terraform-cdk-constructs.PrivateDnsSrvRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(private_dns_record_schemas_1.PRIVATE_DNS_SRV_RECORD_TYPE, private_dns_record_schemas_1.ALL_PRIVATE_DNS_SRV_RECORD_VERSIONS);
+})();
+/**
+ * Azure Private DNS TXT Record implementation
+ *
+ * TXT records store arbitrary text data, commonly used for SPF, DKIM, etc.
+ *
+ * @example
+ * // Create a TXT record for SPF:
+ * const txtRecord = new PrivateDnsTxtRecord(this, "spf-record", {
+ *   name: "@",
+ *   privateDnsZoneId: zone.id,
+ *   ttl: 3600,
+ *   records: [
+ *     { value: ["v=spf1 include:spf.protection.outlook.com -all"] },
+ *   ],
+ * });
+ *
+ * @stability stable
+ */
+class PrivateDnsTxtRecord 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.privateDnsZoneId;
+    }
+    defaultVersion() {
+        return "2024-06-01";
+    }
+    resourceType() {
+        return private_dns_record_schemas_1.PRIVATE_DNS_TXT_RECORD_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    supportsTags() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        const body = {
+            properties: {
+                ttl: typedProps.ttl ?? 3600,
+                txtRecords: typedProps.records.map((r) => ({ value: r.value })),
+            },
+        };
+        if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {
+            body.properties.metadata =
+                typedProps.metadata;
+        }
+        return body;
+    }
+    /**
+     * Get the FQDN of the record
+     */
+    get fqdn() {
+        return `\${${this.terraformResource.fqn}.output.properties.fqdn}`;
+    }
+}
+exports.PrivateDnsTxtRecord = PrivateDnsTxtRecord;
+_h = JSII_RTTI_SYMBOL_1;
+PrivateDnsTxtRecord[_h] = { fqn: "@microsoft/terraform-cdk-constructs.PrivateDnsTxtRecord", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(private_dns_record_schemas_1.PRIVATE_DNS_TXT_RECORD_TYPE, private_dns_record_schemas_1.ALL_PRIVATE_DNS_TXT_RECORD_VERSIONS);
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"private-dns-records.js","sourceRoot":"","sources":["../../../../src/azure-privatednszone/lib/records/private-dns-records.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Azure Private DNS Zone Record implementations using AzapiResource framework\n *\n * This file provides implementations for all Private DNS Zone record types:\n * - PrivateDnsARecord (A records with IPv4 addresses)\n * - PrivateDnsAaaaRecord (AAAA records with IPv6 addresses)\n * - PrivateDnsCnameRecord (CNAME records)\n * - PrivateDnsMxRecord (MX records with exchange and preference)\n * - PrivateDnsPtrRecord (PTR records)\n * - PrivateDnsSoaRecord (SOA records)\n * - PrivateDnsSrvRecord (SRV records with priority, weight, port, target)\n * - PrivateDnsTxtRecord (TXT records)\n *\n * API Version: 2024-06-01\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_PRIVATE_DNS_A_RECORD_VERSIONS,\n  ALL_PRIVATE_DNS_AAAA_RECORD_VERSIONS,\n  ALL_PRIVATE_DNS_CNAME_RECORD_VERSIONS,\n  ALL_PRIVATE_DNS_MX_RECORD_VERSIONS,\n  ALL_PRIVATE_DNS_PTR_RECORD_VERSIONS,\n  ALL_PRIVATE_DNS_SOA_RECORD_VERSIONS,\n  ALL_PRIVATE_DNS_SRV_RECORD_VERSIONS,\n  ALL_PRIVATE_DNS_TXT_RECORD_VERSIONS,\n  PRIVATE_DNS_A_RECORD_TYPE,\n  PRIVATE_DNS_AAAA_RECORD_TYPE,\n  PRIVATE_DNS_CNAME_RECORD_TYPE,\n  PRIVATE_DNS_MX_RECORD_TYPE,\n  PRIVATE_DNS_PTR_RECORD_TYPE,\n  PRIVATE_DNS_SOA_RECORD_TYPE,\n  PRIVATE_DNS_SRV_RECORD_TYPE,\n  PRIVATE_DNS_TXT_RECORD_TYPE,\n} from \"./private-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 Private 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 PrivateDnsRecordBaseProps extends AzapiResourceProps {\n  /**\n   * Resource ID of the parent Private DNS Zone\n   * @example zone.id or \"/subscriptions/.../providers/Microsoft.Network/privateDnsZones/example.com\"\n   */\n  readonly privateDnsZoneId: 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 ARecordEntry {\n  /**\n   * The IPv4 address of this A record\n   * @example \"10.0.1.4\"\n   */\n  readonly ipv4Address: string;\n}\n\n/**\n * Properties for Private DNS A Record\n */\nexport interface PrivateDnsARecordProps extends PrivateDnsRecordBaseProps {\n  /**\n   * Array of A records with IPv4 addresses\n   */\n  readonly records: ARecordEntry[];\n}\n\n/**\n * Azure Private DNS A Record implementation\n *\n * A records map a hostname to one or more IPv4 addresses.\n *\n * @example\n * // Create an A record with multiple IP addresses:\n * const aRecord = new PrivateDnsARecord(this, \"web-a-record\", {\n *   name: \"www\",\n *   privateDnsZoneId: zone.id,\n *   ttl: 300,\n *   records: [\n *     { ipv4Address: \"10.0.1.4\" },\n *     { ipv4Address: \"10.0.1.5\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class PrivateDnsARecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      PRIVATE_DNS_A_RECORD_TYPE,\n      ALL_PRIVATE_DNS_A_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: PrivateDnsARecordProps;\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: PrivateDnsARecordProps) {\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 PrivateDnsARecordProps;\n    return typedProps.privateDnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2024-06-01\";\n  }\n\n  protected resourceType(): string {\n    return PRIVATE_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 PrivateDnsARecordProps;\n    const body: { [key: string]: object } = {\n      properties: {\n        ttl: typedProps.ttl ?? 3600,\n        aRecords: typedProps.records.map((r) => ({\n          ipv4Address: r.ipv4Address,\n        })),\n      },\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      (body.properties as { [key: string]: unknown }).metadata =\n        typedProps.metadata;\n    }\n\n    return body;\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 AaaaRecordEntry {\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 Private DNS AAAA Record\n */\nexport interface PrivateDnsAaaaRecordProps extends PrivateDnsRecordBaseProps {\n  /**\n   * Array of AAAA records with IPv6 addresses\n   */\n  readonly records: AaaaRecordEntry[];\n}\n\n/**\n * Azure Private DNS AAAA Record implementation\n *\n * AAAA records map a hostname to one or more IPv6 addresses.\n *\n * @example\n * // Create an AAAA record:\n * const aaaaRecord = new PrivateDnsAaaaRecord(this, \"web-aaaa-record\", {\n *   name: \"www\",\n *   privateDnsZoneId: zone.id,\n *   ttl: 300,\n *   records: [\n *     { ipv6Address: \"2001:db8::1\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class PrivateDnsAaaaRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      PRIVATE_DNS_AAAA_RECORD_TYPE,\n      ALL_PRIVATE_DNS_AAAA_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: PrivateDnsAaaaRecordProps;\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: PrivateDnsAaaaRecordProps) {\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 PrivateDnsAaaaRecordProps;\n    return typedProps.privateDnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2024-06-01\";\n  }\n\n  protected resourceType(): string {\n    return PRIVATE_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 PrivateDnsAaaaRecordProps;\n    const body: { [key: string]: object } = {\n      properties: {\n        ttl: typedProps.ttl ?? 3600,\n        aaaaRecords: typedProps.records.map((r) => ({\n          ipv6Address: r.ipv6Address,\n        })),\n      },\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      (body.properties as { [key: string]: unknown }).metadata =\n        typedProps.metadata;\n    }\n\n    return body;\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 Private DNS CNAME Record\n */\nexport interface PrivateDnsCnameRecordProps extends PrivateDnsRecordBaseProps {\n  /**\n   * The canonical name for this CNAME record\n   * @example \"www.contoso.com\"\n   */\n  readonly cname: string;\n}\n\n/**\n * Azure Private DNS CNAME Record implementation\n *\n * CNAME records create an alias from one hostname to another.\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 PrivateDnsCnameRecord(this, \"alias-record\", {\n *   name: \"app\",\n *   privateDnsZoneId: zone.id,\n *   ttl: 3600,\n *   cname: \"www.internal.example.com\",\n * });\n *\n * @stability stable\n */\nexport class PrivateDnsCnameRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      PRIVATE_DNS_CNAME_RECORD_TYPE,\n      ALL_PRIVATE_DNS_CNAME_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: PrivateDnsCnameRecordProps;\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: PrivateDnsCnameRecordProps) {\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 PrivateDnsCnameRecordProps;\n    return typedProps.privateDnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2024-06-01\";\n  }\n\n  protected resourceType(): string {\n    return PRIVATE_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 PrivateDnsCnameRecordProps;\n    const body: { [key: string]: object } = {\n      properties: {\n        ttl: typedProps.ttl ?? 3600,\n        cnameRecord: {\n          cname: typedProps.cname,\n        },\n      },\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      (body.properties as { [key: string]: unknown }).metadata =\n        typedProps.metadata;\n    }\n\n    return body;\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 MxRecordEntry {\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 Private DNS MX Record\n */\nexport interface PrivateDnsMxRecordProps extends PrivateDnsRecordBaseProps {\n  /**\n   * Array of MX records with exchange and preference\n   */\n  readonly records: MxRecordEntry[];\n}\n\n/**\n * Azure Private 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 PrivateDnsMxRecord(this, \"mail-record\", {\n *   name: \"@\",\n *   privateDnsZoneId: zone.id,\n *   ttl: 3600,\n *   records: [\n *     { preference: 10, exchange: \"mail1.internal.example.com\" },\n *     { preference: 20, exchange: \"mail2.internal.example.com\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class PrivateDnsMxRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      PRIVATE_DNS_MX_RECORD_TYPE,\n      ALL_PRIVATE_DNS_MX_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: PrivateDnsMxRecordProps;\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: PrivateDnsMxRecordProps) {\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 PrivateDnsMxRecordProps;\n    return typedProps.privateDnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2024-06-01\";\n  }\n\n  protected resourceType(): string {\n    return PRIVATE_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 PrivateDnsMxRecordProps;\n    const body: { [key: string]: object } = {\n      properties: {\n        ttl: typedProps.ttl ?? 3600,\n        mxRecords: typedProps.records.map((r) => ({\n          preference: r.preference,\n          exchange: r.exchange,\n        })),\n      },\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      (body.properties as { [key: string]: unknown }).metadata =\n        typedProps.metadata;\n    }\n\n    return body;\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 PtrRecordEntry {\n  /**\n   * The PTR target domain name\n   * @example \"server1.internal.example.com\"\n   */\n  readonly ptrdname: string;\n}\n\n/**\n * Properties for Private DNS PTR Record\n */\nexport interface PrivateDnsPtrRecordProps extends PrivateDnsRecordBaseProps {\n  /**\n   * Array of PTR records with ptrdname values\n   */\n  readonly records: PtrRecordEntry[];\n}\n\n/**\n * Azure Private 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 PrivateDnsPtrRecord(this, \"ptr-record\", {\n *   name: \"4.1.0.10.in-addr.arpa\",\n *   privateDnsZoneId: reverseZone.id,\n *   ttl: 3600,\n *   records: [\n *     { ptrdname: \"server1.internal.example.com\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class PrivateDnsPtrRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      PRIVATE_DNS_PTR_RECORD_TYPE,\n      ALL_PRIVATE_DNS_PTR_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: PrivateDnsPtrRecordProps;\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: PrivateDnsPtrRecordProps) {\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 PrivateDnsPtrRecordProps;\n    return typedProps.privateDnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2024-06-01\";\n  }\n\n  protected resourceType(): string {\n    return PRIVATE_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 PrivateDnsPtrRecordProps;\n    const body: { [key: string]: object } = {\n      properties: {\n        ttl: typedProps.ttl ?? 3600,\n        ptrRecords: typedProps.records.map((r) => ({ ptrdname: r.ptrdname })),\n      },\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      (body.properties as { [key: string]: unknown }).metadata =\n        typedProps.metadata;\n    }\n\n    return body;\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 SoaRecordConfig {\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 Private DNS SOA Record\n */\nexport interface PrivateDnsSoaRecordProps extends PrivateDnsRecordBaseProps {\n  /**\n   * SOA record configuration\n   */\n  readonly soaRecord: SoaRecordConfig;\n}\n\n/**\n * Azure Private 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 PrivateDnsSoaRecord(this, \"soa-record\", {\n *   name: \"@\",\n *   privateDnsZoneId: 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 PrivateDnsSoaRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      PRIVATE_DNS_SOA_RECORD_TYPE,\n      ALL_PRIVATE_DNS_SOA_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: PrivateDnsSoaRecordProps;\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: PrivateDnsSoaRecordProps) {\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 PrivateDnsSoaRecordProps;\n    return typedProps.privateDnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2024-06-01\";\n  }\n\n  protected resourceType(): string {\n    return PRIVATE_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 PrivateDnsSoaRecordProps;\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 body: { [key: string]: object } = {\n      properties: {\n        ttl: typedProps.ttl ?? 3600,\n        soaRecord: soaRecord,\n      },\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      (body.properties as { [key: string]: unknown }).metadata =\n        typedProps.metadata;\n    }\n\n    return body;\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 SrvRecordEntry {\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.internal.example.com\"\n   */\n  readonly target: string;\n}\n\n/**\n * Properties for Private DNS SRV Record\n */\nexport interface PrivateDnsSrvRecordProps extends PrivateDnsRecordBaseProps {\n  /**\n   * Array of SRV records with priority, weight, port, and target\n   */\n  readonly records: SrvRecordEntry[];\n}\n\n/**\n * Azure Private 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 PrivateDnsSrvRecord(this, \"sip-record\", {\n *   name: \"_sip._tcp\",\n *   privateDnsZoneId: zone.id,\n *   ttl: 3600,\n *   records: [\n *     { priority: 10, weight: 60, port: 5060, target: \"sipserver1.internal.example.com\" },\n *     { priority: 10, weight: 40, port: 5060, target: \"sipserver2.internal.example.com\" },\n *   ],\n * });\n *\n * @stability stable\n */\nexport class PrivateDnsSrvRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      PRIVATE_DNS_SRV_RECORD_TYPE,\n      ALL_PRIVATE_DNS_SRV_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: PrivateDnsSrvRecordProps;\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: PrivateDnsSrvRecordProps) {\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 PrivateDnsSrvRecordProps;\n    return typedProps.privateDnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2024-06-01\";\n  }\n\n  protected resourceType(): string {\n    return PRIVATE_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 PrivateDnsSrvRecordProps;\n    const body: { [key: string]: object } = {\n      properties: {\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\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      (body.properties as { [key: string]: unknown }).metadata =\n        typedProps.metadata;\n    }\n\n    return body;\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 TxtRecordEntry {\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 Private DNS TXT Record\n */\nexport interface PrivateDnsTxtRecordProps extends PrivateDnsRecordBaseProps {\n  /**\n   * Array of TXT records with string values\n   */\n  readonly records: TxtRecordEntry[];\n}\n\n/**\n * Azure Private DNS TXT Record implementation\n *\n * TXT records store arbitrary text data, commonly used for SPF, DKIM, etc.\n *\n * @example\n * // Create a TXT record for SPF:\n * const txtRecord = new PrivateDnsTxtRecord(this, \"spf-record\", {\n *   name: \"@\",\n *   privateDnsZoneId: 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 PrivateDnsTxtRecord extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      PRIVATE_DNS_TXT_RECORD_TYPE,\n      ALL_PRIVATE_DNS_TXT_RECORD_VERSIONS,\n    );\n  }\n\n  public readonly props: PrivateDnsTxtRecordProps;\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: PrivateDnsTxtRecordProps) {\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 PrivateDnsTxtRecordProps;\n    return typedProps.privateDnsZoneId;\n  }\n\n  protected defaultVersion(): string {\n    return \"2024-06-01\";\n  }\n\n  protected resourceType(): string {\n    return PRIVATE_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 PrivateDnsTxtRecordProps;\n    const body: { [key: string]: object } = {\n      properties: {\n        ttl: typedProps.ttl ?? 3600,\n        txtRecords: typedProps.records.map((r) => ({ value: r.value })),\n      },\n    };\n\n    if (typedProps.metadata && Object.keys(typedProps.metadata).length > 0) {\n      (body.properties as { [key: string]: unknown }).metadata =\n        typedProps.metadata;\n    }\n\n    return body;\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"]}