@distilled.cloud/cloudflare 0.0.0-john

package/lib/services/dns.js

@@ -0,0 +1,4627 @@
+/**
+ * Cloudflare DNS API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service dns
+ */
+import * as stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import * as API from "../client/api.js";
+import * as T from "../traits.js";
+import {} from "../errors.js";
+import { SensitiveString } from "../sensitive.js";
+export const GetAnalyticReportRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    dimensions: Schema.optional(Schema.String).pipe(T.HttpQuery("dimensions")),
+    filters: Schema.optional(Schema.String).pipe(T.HttpQuery("filters")),
+    limit: Schema.optional(Schema.Number).pipe(T.HttpQuery("limit")),
+    metrics: Schema.optional(Schema.String).pipe(T.HttpQuery("metrics")),
+    since: Schema.optional(Schema.String).pipe(T.HttpQuery("since")),
+    sort: Schema.optional(Schema.String).pipe(T.HttpQuery("sort")),
+    until: Schema.optional(Schema.String).pipe(T.HttpQuery("until")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/dns_analytics/report" }));
+export const GetAnalyticReportResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Array(Schema.Struct({
+        dimensions: Schema.Array(Schema.String),
+        metrics: Schema.Array(Schema.Number),
+    })),
+    dataLag: Schema.Number,
+    max: Schema.Unknown,
+    min: Schema.Unknown,
+    query: Schema.Struct({
+        dimensions: Schema.Array(Schema.String),
+        limit: Schema.Number,
+        metrics: Schema.Array(Schema.String),
+        since: Schema.String,
+        until: Schema.String,
+        filters: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        sort: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    }),
+    rows: Schema.Number,
+    totals: Schema.Unknown,
+})
+    .pipe(Schema.encodeKeys({
+    data: "data",
+    dataLag: "data_lag",
+    max: "max",
+    min: "min",
+    query: "query",
+    rows: "rows",
+    totals: "totals",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getAnalyticReport = API.make(() => ({
+    input: GetAnalyticReportRequest,
+    output: GetAnalyticReportResponse,
+    errors: [],
+}));
+export const GetAnalyticReportBytimeRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    dimensions: Schema.optional(Schema.String).pipe(T.HttpQuery("dimensions")),
+    filters: Schema.optional(Schema.String).pipe(T.HttpQuery("filters")),
+    limit: Schema.optional(Schema.Number).pipe(T.HttpQuery("limit")),
+    metrics: Schema.optional(Schema.String).pipe(T.HttpQuery("metrics")),
+    since: Schema.optional(Schema.String).pipe(T.HttpQuery("since")),
+    sort: Schema.optional(Schema.String).pipe(T.HttpQuery("sort")),
+    timeDelta: Schema.optional(Schema.Literals([
+        "all",
+        "auto",
+        "year",
+        "quarter",
+        "month",
+        "week",
+        "day",
+        "hour",
+        "dekaminute",
+        "minute",
+    ])).pipe(T.HttpQuery("time_delta")),
+    until: Schema.optional(Schema.String).pipe(T.HttpQuery("until")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/zones/{zone_id}/dns_analytics/report/bytime",
+}));
+export const GetAnalyticReportBytimeResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Array(Schema.Struct({
+        dimensions: Schema.Array(Schema.String),
+        metrics: Schema.Array(Schema.Array(Schema.Number)),
+    })),
+    dataLag: Schema.Number,
+    max: Schema.Unknown,
+    min: Schema.Unknown,
+    query: Schema.Struct({
+        dimensions: Schema.Array(Schema.String),
+        limit: Schema.Number,
+        metrics: Schema.Array(Schema.String),
+        since: Schema.String,
+        timeDelta: Schema.Literals([
+            "all",
+            "auto",
+            "year",
+            "quarter",
+            "month",
+            "week",
+            "day",
+            "hour",
+            "dekaminute",
+            "minute",
+        ]),
+        until: Schema.String,
+        filters: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        sort: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        dimensions: "dimensions",
+        limit: "limit",
+        metrics: "metrics",
+        since: "since",
+        timeDelta: "time_delta",
+        until: "until",
+        filters: "filters",
+        sort: "sort",
+    })),
+    rows: Schema.Number,
+    timeIntervals: Schema.Array(Schema.Array(Schema.String)),
+    totals: Schema.Unknown,
+})
+    .pipe(Schema.encodeKeys({
+    data: "data",
+    dataLag: "data_lag",
+    max: "max",
+    min: "min",
+    query: "query",
+    rows: "rows",
+    timeIntervals: "time_intervals",
+    totals: "totals",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getAnalyticReportBytime = API.make(() => ({
+    input: GetAnalyticReportBytimeRequest,
+    output: GetAnalyticReportBytimeResponse,
+    errors: [],
+}));
+export const GetDnssecRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/dnssec" }));
+export const GetDnssecResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    algorithm: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    digest: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    digestAlgorithm: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    digestType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    dnssecMultiSigner: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    dnssecPresigned: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    dnssecUseNsec3: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    ds: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    flags: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    keyTag: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    keyType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    publicKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    status: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "active",
+            "pending",
+            "disabled",
+            "pending-disabled",
+            "error",
+        ]),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    algorithm: "algorithm",
+    digest: "digest",
+    digestAlgorithm: "digest_algorithm",
+    digestType: "digest_type",
+    dnssecMultiSigner: "dnssec_multi_signer",
+    dnssecPresigned: "dnssec_presigned",
+    dnssecUseNsec3: "dnssec_use_nsec3",
+    ds: "ds",
+    flags: "flags",
+    keyTag: "key_tag",
+    keyType: "key_type",
+    modifiedOn: "modified_on",
+    publicKey: "public_key",
+    status: "status",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getDnssec = API.make(() => ({
+    input: GetDnssecRequest,
+    output: GetDnssecResponse,
+    errors: [],
+}));
+export const PatchDnssecRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    dnssecMultiSigner: Schema.optional(Schema.Boolean),
+    dnssecPresigned: Schema.optional(Schema.Boolean),
+    dnssecUseNsec3: Schema.optional(Schema.Boolean),
+    status: Schema.optional(Schema.Literals(["active", "disabled"])),
+}).pipe(Schema.encodeKeys({
+    dnssecMultiSigner: "dnssec_multi_signer",
+    dnssecPresigned: "dnssec_presigned",
+    dnssecUseNsec3: "dnssec_use_nsec3",
+    status: "status",
+}), T.Http({ method: "PATCH", path: "/zones/{zone_id}/dnssec" }));
+export const PatchDnssecResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    algorithm: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    digest: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    digestAlgorithm: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    digestType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    dnssecMultiSigner: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    dnssecPresigned: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    dnssecUseNsec3: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    ds: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    flags: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    keyTag: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    keyType: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    publicKey: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    status: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "active",
+            "pending",
+            "disabled",
+            "pending-disabled",
+            "error",
+        ]),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    algorithm: "algorithm",
+    digest: "digest",
+    digestAlgorithm: "digest_algorithm",
+    digestType: "digest_type",
+    dnssecMultiSigner: "dnssec_multi_signer",
+    dnssecPresigned: "dnssec_presigned",
+    dnssecUseNsec3: "dnssec_use_nsec3",
+    ds: "ds",
+    flags: "flags",
+    keyTag: "key_tag",
+    keyType: "key_type",
+    modifiedOn: "modified_on",
+    publicKey: "public_key",
+    status: "status",
+}))
+    .pipe(T.ResponsePath("result"));
+export const patchDnssec = API.make(() => ({
+    input: PatchDnssecRequest,
+    output: PatchDnssecResponse,
+    errors: [],
+}));
+export const DeleteDnssecRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({ method: "DELETE", path: "/zones/{zone_id}/dnssec" }));
+export const DeleteDnssecResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result"));
+export const deleteDnssec = API.make(() => ({
+    input: DeleteDnssecRequest,
+    output: DeleteDnssecResponse,
+    errors: [],
+}));
+export const ScanListRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/dns_records/scan/review" }));
+export const ScanListRecordResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Union([
+        Schema.Struct({
+            id: Schema.String,
+            createdOn: Schema.String,
+            meta: Schema.Unknown,
+            modifiedOn: Schema.String,
+            proxiable: Schema.Boolean,
+            commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            id: "id",
+            createdOn: "created_on",
+            meta: "meta",
+            modifiedOn: "modified_on",
+            proxiable: "proxiable",
+            commentModifiedOn: "comment_modified_on",
+            tagsModifiedOn: "tags_modified_on",
+        })),
+        Schema.Struct({
+            id: Schema.String,
+            comment: Schema.String,
+            content: Schema.String,
+            createdOn: Schema.String,
+            meta: Schema.Unknown,
+            modifiedOn: Schema.String,
+            name: Schema.String,
+            proxiable: Schema.Boolean,
+            proxied: Schema.Boolean,
+            settings: Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            }).pipe(Schema.encodeKeys({ ipv4Only: "ipv4_only", ipv6Only: "ipv6_only" })),
+            tags: Schema.Array(Schema.String),
+            ttl: Schema.Number,
+            type: Schema.Literal("OPENPGPKEY"),
+            commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            id: "id",
+            comment: "comment",
+            content: "content",
+            createdOn: "created_on",
+            meta: "meta",
+            modifiedOn: "modified_on",
+            name: "name",
+            proxiable: "proxiable",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+            ttl: "ttl",
+            type: "type",
+            commentModifiedOn: "comment_modified_on",
+            tagsModifiedOn: "tags_modified_on",
+        })),
+    ])),
+});
+export const scanListRecord = API.makePaginated(() => ({
+    input: ScanListRecordRequest,
+    output: ScanListRecordResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const ForceNotifyZoneTransferOutgoingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    body: Schema.Unknown.pipe(T.HttpBody()),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/zones/{zone_id}/secondary_dns/outgoing/force_notify",
+}));
+export const ForceNotifyZoneTransferOutgoingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result"));
+export const forceNotifyZoneTransferOutgoing = API.make(() => ({
+    input: ForceNotifyZoneTransferOutgoingRequest,
+    output: ForceNotifyZoneTransferOutgoingResponse,
+    errors: [],
+}));
+export const GetRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dnsRecordId: Schema.String.pipe(T.HttpPath("dnsRecordId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/dns_records/{dnsRecordId}" }));
+export const GetRecordResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.Struct({
+        id: Schema.String,
+        createdOn: Schema.String,
+        meta: Schema.Unknown,
+        modifiedOn: Schema.String,
+        proxiable: Schema.Boolean,
+        commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        createdOn: "created_on",
+        meta: "meta",
+        modifiedOn: "modified_on",
+        proxiable: "proxiable",
+        commentModifiedOn: "comment_modified_on",
+        tagsModifiedOn: "tags_modified_on",
+    })),
+    Schema.Struct({
+        id: Schema.String,
+        comment: Schema.String,
+        content: Schema.String,
+        createdOn: Schema.String,
+        meta: Schema.Unknown,
+        modifiedOn: Schema.String,
+        name: Schema.String,
+        proxiable: Schema.Boolean,
+        proxied: Schema.Boolean,
+        settings: Schema.Struct({
+            ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ ipv4Only: "ipv4_only", ipv6Only: "ipv6_only" })),
+        tags: Schema.Array(Schema.String),
+        ttl: Schema.Number,
+        type: Schema.Literal("OPENPGPKEY"),
+        commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        comment: "comment",
+        content: "content",
+        createdOn: "created_on",
+        meta: "meta",
+        modifiedOn: "modified_on",
+        name: "name",
+        proxiable: "proxiable",
+        proxied: "proxied",
+        settings: "settings",
+        tags: "tags",
+        ttl: "ttl",
+        type: "type",
+        commentModifiedOn: "comment_modified_on",
+        tagsModifiedOn: "tags_modified_on",
+    })),
+]).pipe(T.ResponsePath("result"));
+export const getRecord = API.make(() => ({
+    input: GetRecordRequest,
+    output: GetRecordResponse,
+    errors: [],
+}));
+export const ListRecordsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    comment: Schema.optional(Schema.Struct({
+        absent: Schema.optional(Schema.String),
+        contains: Schema.optional(Schema.String),
+        endswith: Schema.optional(Schema.String),
+        exact: Schema.optional(Schema.String),
+        present: Schema.optional(Schema.String),
+        startswith: Schema.optional(Schema.String),
+    })).pipe(T.HttpQuery("comment")),
+    content: Schema.optional(Schema.Struct({
+        contains: Schema.optional(Schema.String),
+        endswith: Schema.optional(Schema.String),
+        exact: Schema.optional(Schema.String),
+        startswith: Schema.optional(Schema.String),
+    })).pipe(T.HttpQuery("content")),
+    direction: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(T.HttpQuery("direction")),
+    match: Schema.optional(Schema.Literals(["any", "all"])).pipe(T.HttpQuery("match")),
+    name: Schema.optional(Schema.Struct({
+        contains: Schema.optional(Schema.String),
+        endswith: Schema.optional(Schema.String),
+        exact: Schema.optional(Schema.String),
+        startswith: Schema.optional(Schema.String),
+    })).pipe(T.HttpQuery("name")),
+    order: Schema.optional(Schema.Literals(["type", "name", "content", "ttl", "proxied"])).pipe(T.HttpQuery("order")),
+    proxied: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("proxied")),
+    search: Schema.optional(Schema.String).pipe(T.HttpQuery("search")),
+    tag: Schema.optional(Schema.Struct({
+        absent: Schema.optional(Schema.String),
+        contains: Schema.optional(Schema.String),
+        endswith: Schema.optional(Schema.String),
+        exact: Schema.optional(Schema.String),
+        present: Schema.optional(Schema.String),
+        startswith: Schema.optional(Schema.String),
+    })).pipe(T.HttpQuery("tag")),
+    tagMatch: Schema.optional(Schema.Literals(["any", "all"])).pipe(T.HttpQuery("tag_match")),
+    type: Schema.optional(Schema.Literals([
+        "A",
+        "AAAA",
+        "CAA",
+        "CERT",
+        "CNAME",
+        "DNSKEY",
+        "DS",
+        "HTTPS",
+        "LOC",
+        "MX",
+        "NAPTR",
+        "NS",
+        "OPENPGPKEY",
+        "PTR",
+        "SMIMEA",
+        "SRV",
+        "SSHFP",
+        "SVCB",
+        "TLSA",
+        "TXT",
+        "URI",
+    ])).pipe(T.HttpQuery("type")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/dns_records" }));
+export const ListRecordsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Union([
+        Schema.Struct({
+            id: Schema.String,
+            createdOn: Schema.String,
+            meta: Schema.Unknown,
+            modifiedOn: Schema.String,
+            proxiable: Schema.Boolean,
+            commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            id: "id",
+            createdOn: "created_on",
+            meta: "meta",
+            modifiedOn: "modified_on",
+            proxiable: "proxiable",
+            commentModifiedOn: "comment_modified_on",
+            tagsModifiedOn: "tags_modified_on",
+        })),
+        Schema.Struct({
+            id: Schema.String,
+            comment: Schema.String,
+            content: Schema.String,
+            createdOn: Schema.String,
+            meta: Schema.Unknown,
+            modifiedOn: Schema.String,
+            name: Schema.String,
+            proxiable: Schema.Boolean,
+            proxied: Schema.Boolean,
+            settings: Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            }).pipe(Schema.encodeKeys({ ipv4Only: "ipv4_only", ipv6Only: "ipv6_only" })),
+            tags: Schema.Array(Schema.String),
+            ttl: Schema.Number,
+            type: Schema.Literal("OPENPGPKEY"),
+            commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            id: "id",
+            comment: "comment",
+            content: "content",
+            createdOn: "created_on",
+            meta: "meta",
+            modifiedOn: "modified_on",
+            name: "name",
+            proxiable: "proxiable",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+            ttl: "ttl",
+            type: "type",
+            commentModifiedOn: "comment_modified_on",
+            tagsModifiedOn: "tags_modified_on",
+        })),
+    ])),
+    resultInfo: Schema.Struct({
+        count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        count: "count",
+        page: "page",
+        perPage: "per_page",
+        totalCount: "total_count",
+    })),
+}).pipe(Schema.encodeKeys({ result: "result", resultInfo: "result_info" }));
+export const listRecords = API.makePaginated(() => ({
+    input: ListRecordsRequest,
+    output: ListRecordsResponse,
+    errors: [],
+    pagination: {
+        mode: "page",
+        inputToken: "page",
+        outputToken: "resultInfo.page",
+        items: "result",
+        pageSize: "perPage",
+    },
+}));
+export const CreateRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    name: Schema.String,
+    ttl: Schema.Number,
+    type: Schema.Literal("A"),
+    comment: Schema.optional(Schema.String),
+    content: Schema.optional(Schema.String),
+    proxied: Schema.optional(Schema.Boolean),
+    settings: Schema.optional(Schema.Struct({
+        ipv4Only: Schema.optional(Schema.Boolean),
+        ipv6Only: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.encodeKeys({ ipv4Only: "ipv4_only", ipv6Only: "ipv6_only" }))),
+    tags: Schema.optional(Schema.Array(Schema.String)),
+}).pipe(T.Http({ method: "POST", path: "/zones/{zone_id}/dns_records" }));
+export const CreateRecordResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.Struct({
+        id: Schema.String,
+        createdOn: Schema.String,
+        meta: Schema.Unknown,
+        modifiedOn: Schema.String,
+        proxiable: Schema.Boolean,
+        commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        createdOn: "created_on",
+        meta: "meta",
+        modifiedOn: "modified_on",
+        proxiable: "proxiable",
+        commentModifiedOn: "comment_modified_on",
+        tagsModifiedOn: "tags_modified_on",
+    })),
+    Schema.Struct({
+        id: Schema.String,
+        comment: Schema.String,
+        content: Schema.String,
+        createdOn: Schema.String,
+        meta: Schema.Unknown,
+        modifiedOn: Schema.String,
+        name: Schema.String,
+        proxiable: Schema.Boolean,
+        proxied: Schema.Boolean,
+        settings: Schema.Struct({
+            ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ ipv4Only: "ipv4_only", ipv6Only: "ipv6_only" })),
+        tags: Schema.Array(Schema.String),
+        ttl: Schema.Number,
+        type: Schema.Literal("OPENPGPKEY"),
+        commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        comment: "comment",
+        content: "content",
+        createdOn: "created_on",
+        meta: "meta",
+        modifiedOn: "modified_on",
+        name: "name",
+        proxiable: "proxiable",
+        proxied: "proxied",
+        settings: "settings",
+        tags: "tags",
+        ttl: "ttl",
+        type: "type",
+        commentModifiedOn: "comment_modified_on",
+        tagsModifiedOn: "tags_modified_on",
+    })),
+]).pipe(T.ResponsePath("result"));
+export const createRecord = API.make(() => ({
+    input: CreateRecordRequest,
+    output: CreateRecordResponse,
+    errors: [],
+}));
+export const UpdateRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dnsRecordId: Schema.String.pipe(T.HttpPath("dnsRecordId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    name: Schema.String,
+    ttl: Schema.Number,
+    type: Schema.Literal("A"),
+    comment: Schema.optional(Schema.String),
+    content: Schema.optional(Schema.String),
+    proxied: Schema.optional(Schema.Boolean),
+    settings: Schema.optional(Schema.Struct({
+        ipv4Only: Schema.optional(Schema.Boolean),
+        ipv6Only: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.encodeKeys({ ipv4Only: "ipv4_only", ipv6Only: "ipv6_only" }))),
+    tags: Schema.optional(Schema.Array(Schema.String)),
+}).pipe(T.Http({ method: "PUT", path: "/zones/{zone_id}/dns_records/{dnsRecordId}" }));
+export const UpdateRecordResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.Struct({
+        id: Schema.String,
+        createdOn: Schema.String,
+        meta: Schema.Unknown,
+        modifiedOn: Schema.String,
+        proxiable: Schema.Boolean,
+        commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        createdOn: "created_on",
+        meta: "meta",
+        modifiedOn: "modified_on",
+        proxiable: "proxiable",
+        commentModifiedOn: "comment_modified_on",
+        tagsModifiedOn: "tags_modified_on",
+    })),
+    Schema.Struct({
+        id: Schema.String,
+        comment: Schema.String,
+        content: Schema.String,
+        createdOn: Schema.String,
+        meta: Schema.Unknown,
+        modifiedOn: Schema.String,
+        name: Schema.String,
+        proxiable: Schema.Boolean,
+        proxied: Schema.Boolean,
+        settings: Schema.Struct({
+            ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ ipv4Only: "ipv4_only", ipv6Only: "ipv6_only" })),
+        tags: Schema.Array(Schema.String),
+        ttl: Schema.Number,
+        type: Schema.Literal("OPENPGPKEY"),
+        commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        comment: "comment",
+        content: "content",
+        createdOn: "created_on",
+        meta: "meta",
+        modifiedOn: "modified_on",
+        name: "name",
+        proxiable: "proxiable",
+        proxied: "proxied",
+        settings: "settings",
+        tags: "tags",
+        ttl: "ttl",
+        type: "type",
+        commentModifiedOn: "comment_modified_on",
+        tagsModifiedOn: "tags_modified_on",
+    })),
+]).pipe(T.ResponsePath("result"));
+export const updateRecord = API.make(() => ({
+    input: UpdateRecordRequest,
+    output: UpdateRecordResponse,
+    errors: [],
+}));
+export const PatchRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dnsRecordId: Schema.String.pipe(T.HttpPath("dnsRecordId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    name: Schema.String,
+    ttl: Schema.Number,
+    type: Schema.Literal("A"),
+    comment: Schema.optional(Schema.String),
+    content: Schema.optional(Schema.String),
+    proxied: Schema.optional(Schema.Boolean),
+    settings: Schema.optional(Schema.Struct({
+        ipv4Only: Schema.optional(Schema.Boolean),
+        ipv6Only: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.encodeKeys({ ipv4Only: "ipv4_only", ipv6Only: "ipv6_only" }))),
+    tags: Schema.optional(Schema.Array(Schema.String)),
+}).pipe(T.Http({
+    method: "PATCH",
+    path: "/zones/{zone_id}/dns_records/{dnsRecordId}",
+}));
+export const PatchRecordResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.Struct({
+        id: Schema.String,
+        createdOn: Schema.String,
+        meta: Schema.Unknown,
+        modifiedOn: Schema.String,
+        proxiable: Schema.Boolean,
+        commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        createdOn: "created_on",
+        meta: "meta",
+        modifiedOn: "modified_on",
+        proxiable: "proxiable",
+        commentModifiedOn: "comment_modified_on",
+        tagsModifiedOn: "tags_modified_on",
+    })),
+    Schema.Struct({
+        id: Schema.String,
+        comment: Schema.String,
+        content: Schema.String,
+        createdOn: Schema.String,
+        meta: Schema.Unknown,
+        modifiedOn: Schema.String,
+        name: Schema.String,
+        proxiable: Schema.Boolean,
+        proxied: Schema.Boolean,
+        settings: Schema.Struct({
+            ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+            ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ ipv4Only: "ipv4_only", ipv6Only: "ipv6_only" })),
+        tags: Schema.Array(Schema.String),
+        ttl: Schema.Number,
+        type: Schema.Literal("OPENPGPKEY"),
+        commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        comment: "comment",
+        content: "content",
+        createdOn: "created_on",
+        meta: "meta",
+        modifiedOn: "modified_on",
+        name: "name",
+        proxiable: "proxiable",
+        proxied: "proxied",
+        settings: "settings",
+        tags: "tags",
+        ttl: "ttl",
+        type: "type",
+        commentModifiedOn: "comment_modified_on",
+        tagsModifiedOn: "tags_modified_on",
+    })),
+]).pipe(T.ResponsePath("result"));
+export const patchRecord = API.make(() => ({
+    input: PatchRecordRequest,
+    output: PatchRecordResponse,
+    errors: [],
+}));
+export const DeleteRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dnsRecordId: Schema.String.pipe(T.HttpPath("dnsRecordId")),
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/zones/{zone_id}/dns_records/{dnsRecordId}",
+}));
+export const DeleteRecordResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deleteRecord = API.make(() => ({
+    input: DeleteRecordRequest,
+    output: DeleteRecordResponse,
+    errors: [],
+}));
+export const BatchRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    deletes: Schema.optional(Schema.Array(Schema.Struct({
+        id: Schema.String,
+    }))),
+    patches: Schema.optional(Schema.Array(Schema.Union([
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("A"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("AAAA"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CNAME"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                flattenCname: Schema.optional(Schema.Boolean),
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                flattenCname: "flatten_cname",
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("MX"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            priority: Schema.optional(Schema.Number),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            priority: "priority",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("NS"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            id: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("OPENPGPKEY"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("PTR"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("TXT"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CAA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                flags: Schema.optional(Schema.Number),
+                tag: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CERT"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                certificate: Schema.optional(Schema.String),
+                keyTag: Schema.optional(Schema.Number),
+                type: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                certificate: "certificate",
+                keyTag: "key_tag",
+                type: "type",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("DNSKEY"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                flags: Schema.optional(Schema.Number),
+                protocol: Schema.optional(Schema.Number),
+                publicKey: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                flags: "flags",
+                protocol: "protocol",
+                publicKey: "public_key",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("DS"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                digest: Schema.optional(Schema.String),
+                digestType: Schema.optional(Schema.Number),
+                keyTag: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                digest: "digest",
+                digestType: "digest_type",
+                keyTag: "key_tag",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("HTTPS"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("LOC"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                altitude: Schema.optional(Schema.Number),
+                latDegrees: Schema.optional(Schema.Number),
+                latDirection: Schema.optional(Schema.Literals(["N", "S"])),
+                latMinutes: Schema.optional(Schema.Number),
+                latSeconds: Schema.optional(Schema.Number),
+                longDegrees: Schema.optional(Schema.Number),
+                longDirection: Schema.optional(Schema.Literals(["E", "W"])),
+                longMinutes: Schema.optional(Schema.Number),
+                longSeconds: Schema.optional(Schema.Number),
+                precisionHorz: Schema.optional(Schema.Number),
+                precisionVert: Schema.optional(Schema.Number),
+                size: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                altitude: "altitude",
+                latDegrees: "lat_degrees",
+                latDirection: "lat_direction",
+                latMinutes: "lat_minutes",
+                latSeconds: "lat_seconds",
+                longDegrees: "long_degrees",
+                longDirection: "long_direction",
+                longMinutes: "long_minutes",
+                longSeconds: "long_seconds",
+                precisionHorz: "precision_horz",
+                precisionVert: "precision_vert",
+                size: "size",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("NAPTR"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                flags: Schema.optional(Schema.String),
+                order: Schema.optional(Schema.Number),
+                preference: Schema.optional(Schema.Number),
+                regex: Schema.optional(Schema.String),
+                replacement: Schema.optional(Schema.String),
+                service: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SMIMEA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                certificate: Schema.optional(Schema.String),
+                matchingType: Schema.optional(Schema.Number),
+                selector: Schema.optional(Schema.Number),
+                usage: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                certificate: "certificate",
+                matchingType: "matching_type",
+                selector: "selector",
+                usage: "usage",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SRV"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                port: Schema.optional(Schema.Number),
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                weight: Schema.optional(Schema.Number),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SSHFP"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                fingerprint: Schema.optional(Schema.String),
+                type: Schema.optional(Schema.Number),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SVCB"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("TLSA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                certificate: Schema.optional(Schema.String),
+                matchingType: Schema.optional(Schema.Number),
+                selector: Schema.optional(Schema.Number),
+                usage: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                certificate: "certificate",
+                matchingType: "matching_type",
+                selector: "selector",
+                usage: "usage",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("URI"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                target: Schema.optional(Schema.String),
+                weight: Schema.optional(Schema.Number),
+            })),
+            priority: Schema.optional(Schema.Number),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            priority: "priority",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+    ]))),
+    posts: Schema.optional(Schema.Array(Schema.Union([
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("A"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("AAAA"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CNAME"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                flattenCname: Schema.optional(Schema.Boolean),
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                flattenCname: "flatten_cname",
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("MX"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            priority: Schema.optional(Schema.Number),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("NS"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("OPENPGPKEY"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("PTR"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("TXT"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CAA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                flags: Schema.optional(Schema.Number),
+                tag: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CERT"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                certificate: Schema.optional(Schema.String),
+                keyTag: Schema.optional(Schema.Number),
+                type: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                certificate: "certificate",
+                keyTag: "key_tag",
+                type: "type",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("DNSKEY"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                flags: Schema.optional(Schema.Number),
+                protocol: Schema.optional(Schema.Number),
+                publicKey: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                flags: "flags",
+                protocol: "protocol",
+                publicKey: "public_key",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("DS"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                digest: Schema.optional(Schema.String),
+                digestType: Schema.optional(Schema.Number),
+                keyTag: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                digest: "digest",
+                digestType: "digest_type",
+                keyTag: "key_tag",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("HTTPS"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("LOC"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                altitude: Schema.optional(Schema.Number),
+                latDegrees: Schema.optional(Schema.Number),
+                latDirection: Schema.optional(Schema.Literals(["N", "S"])),
+                latMinutes: Schema.optional(Schema.Number),
+                latSeconds: Schema.optional(Schema.Number),
+                longDegrees: Schema.optional(Schema.Number),
+                longDirection: Schema.optional(Schema.Literals(["E", "W"])),
+                longMinutes: Schema.optional(Schema.Number),
+                longSeconds: Schema.optional(Schema.Number),
+                precisionHorz: Schema.optional(Schema.Number),
+                precisionVert: Schema.optional(Schema.Number),
+                size: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                altitude: "altitude",
+                latDegrees: "lat_degrees",
+                latDirection: "lat_direction",
+                latMinutes: "lat_minutes",
+                latSeconds: "lat_seconds",
+                longDegrees: "long_degrees",
+                longDirection: "long_direction",
+                longMinutes: "long_minutes",
+                longSeconds: "long_seconds",
+                precisionHorz: "precision_horz",
+                precisionVert: "precision_vert",
+                size: "size",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("NAPTR"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                flags: Schema.optional(Schema.String),
+                order: Schema.optional(Schema.Number),
+                preference: Schema.optional(Schema.Number),
+                regex: Schema.optional(Schema.String),
+                replacement: Schema.optional(Schema.String),
+                service: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SMIMEA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                certificate: Schema.optional(Schema.String),
+                matchingType: Schema.optional(Schema.Number),
+                selector: Schema.optional(Schema.Number),
+                usage: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                certificate: "certificate",
+                matchingType: "matching_type",
+                selector: "selector",
+                usage: "usage",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SRV"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                port: Schema.optional(Schema.Number),
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                weight: Schema.optional(Schema.Number),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SSHFP"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                fingerprint: Schema.optional(Schema.String),
+                type: Schema.optional(Schema.Number),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SVCB"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("TLSA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                certificate: Schema.optional(Schema.String),
+                matchingType: Schema.optional(Schema.Number),
+                selector: Schema.optional(Schema.Number),
+                usage: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                certificate: "certificate",
+                matchingType: "matching_type",
+                selector: "selector",
+                usage: "usage",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("URI"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                target: Schema.optional(Schema.String),
+                weight: Schema.optional(Schema.Number),
+            })),
+            priority: Schema.optional(Schema.Number),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+    ]))),
+    puts: Schema.optional(Schema.Array(Schema.Union([
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("A"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("AAAA"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CNAME"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                flattenCname: Schema.optional(Schema.Boolean),
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                flattenCname: "flatten_cname",
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("MX"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            priority: Schema.optional(Schema.Number),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            priority: "priority",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("NS"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            id: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("OPENPGPKEY"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("PTR"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("TXT"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            content: "content",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CAA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                flags: Schema.optional(Schema.Number),
+                tag: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CERT"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                certificate: Schema.optional(Schema.String),
+                keyTag: Schema.optional(Schema.Number),
+                type: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                certificate: "certificate",
+                keyTag: "key_tag",
+                type: "type",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("DNSKEY"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                flags: Schema.optional(Schema.Number),
+                protocol: Schema.optional(Schema.Number),
+                publicKey: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                flags: "flags",
+                protocol: "protocol",
+                publicKey: "public_key",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("DS"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                digest: Schema.optional(Schema.String),
+                digestType: Schema.optional(Schema.Number),
+                keyTag: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                digest: "digest",
+                digestType: "digest_type",
+                keyTag: "key_tag",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("HTTPS"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("LOC"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                altitude: Schema.optional(Schema.Number),
+                latDegrees: Schema.optional(Schema.Number),
+                latDirection: Schema.optional(Schema.Literals(["N", "S"])),
+                latMinutes: Schema.optional(Schema.Number),
+                latSeconds: Schema.optional(Schema.Number),
+                longDegrees: Schema.optional(Schema.Number),
+                longDirection: Schema.optional(Schema.Literals(["E", "W"])),
+                longMinutes: Schema.optional(Schema.Number),
+                longSeconds: Schema.optional(Schema.Number),
+                precisionHorz: Schema.optional(Schema.Number),
+                precisionVert: Schema.optional(Schema.Number),
+                size: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                altitude: "altitude",
+                latDegrees: "lat_degrees",
+                latDirection: "lat_direction",
+                latMinutes: "lat_minutes",
+                latSeconds: "lat_seconds",
+                longDegrees: "long_degrees",
+                longDirection: "long_direction",
+                longMinutes: "long_minutes",
+                longSeconds: "long_seconds",
+                precisionHorz: "precision_horz",
+                precisionVert: "precision_vert",
+                size: "size",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("NAPTR"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                flags: Schema.optional(Schema.String),
+                order: Schema.optional(Schema.Number),
+                preference: Schema.optional(Schema.Number),
+                regex: Schema.optional(Schema.String),
+                replacement: Schema.optional(Schema.String),
+                service: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SMIMEA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                certificate: Schema.optional(Schema.String),
+                matchingType: Schema.optional(Schema.Number),
+                selector: Schema.optional(Schema.Number),
+                usage: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                certificate: "certificate",
+                matchingType: "matching_type",
+                selector: "selector",
+                usage: "usage",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SRV"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                port: Schema.optional(Schema.Number),
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                weight: Schema.optional(Schema.Number),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SSHFP"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                fingerprint: Schema.optional(Schema.String),
+                type: Schema.optional(Schema.Number),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SVCB"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("TLSA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                certificate: Schema.optional(Schema.String),
+                matchingType: Schema.optional(Schema.Number),
+                selector: Schema.optional(Schema.Number),
+                usage: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                certificate: "certificate",
+                matchingType: "matching_type",
+                selector: "selector",
+                usage: "usage",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+        Schema.Struct({
+            zoneId: Schema.String,
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("URI"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                target: Schema.optional(Schema.String),
+                weight: Schema.optional(Schema.Number),
+            })),
+            priority: Schema.optional(Schema.Number),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }).pipe(Schema.encodeKeys({
+            zoneId: "zone_id",
+            name: "name",
+            ttl: "ttl",
+            type: "type",
+            comment: "comment",
+            data: "data",
+            priority: "priority",
+            proxied: "proxied",
+            settings: "settings",
+            tags: "tags",
+        })),
+    ]))),
+}).pipe(T.Http({ method: "POST", path: "/zones/{zone_id}/dns_records/batch" }));
+export const BatchRecordResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    deletes: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Union([
+            Schema.Struct({
+                id: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                proxiable: Schema.Boolean,
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                proxiable: "proxiable",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+            Schema.Struct({
+                id: Schema.String,
+                comment: Schema.String,
+                content: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                name: Schema.String,
+                proxiable: Schema.Boolean,
+                proxied: Schema.Boolean,
+                settings: Schema.Struct({
+                    ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                    ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    ipv4Only: "ipv4_only",
+                    ipv6Only: "ipv6_only",
+                })),
+                tags: Schema.Array(Schema.String),
+                ttl: Schema.Number,
+                type: Schema.Literal("OPENPGPKEY"),
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                comment: "comment",
+                content: "content",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                name: "name",
+                proxiable: "proxiable",
+                proxied: "proxied",
+                settings: "settings",
+                tags: "tags",
+                ttl: "ttl",
+                type: "type",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+        ])),
+        Schema.Null,
+    ])),
+    patches: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Union([
+            Schema.Struct({
+                id: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                proxiable: Schema.Boolean,
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                proxiable: "proxiable",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+            Schema.Struct({
+                id: Schema.String,
+                comment: Schema.String,
+                content: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                name: Schema.String,
+                proxiable: Schema.Boolean,
+                proxied: Schema.Boolean,
+                settings: Schema.Struct({
+                    ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                    ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    ipv4Only: "ipv4_only",
+                    ipv6Only: "ipv6_only",
+                })),
+                tags: Schema.Array(Schema.String),
+                ttl: Schema.Number,
+                type: Schema.Literal("OPENPGPKEY"),
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                comment: "comment",
+                content: "content",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                name: "name",
+                proxiable: "proxiable",
+                proxied: "proxied",
+                settings: "settings",
+                tags: "tags",
+                ttl: "ttl",
+                type: "type",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+        ])),
+        Schema.Null,
+    ])),
+    posts: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Union([
+            Schema.Struct({
+                id: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                proxiable: Schema.Boolean,
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                proxiable: "proxiable",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+            Schema.Struct({
+                id: Schema.String,
+                comment: Schema.String,
+                content: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                name: Schema.String,
+                proxiable: Schema.Boolean,
+                proxied: Schema.Boolean,
+                settings: Schema.Struct({
+                    ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                    ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    ipv4Only: "ipv4_only",
+                    ipv6Only: "ipv6_only",
+                })),
+                tags: Schema.Array(Schema.String),
+                ttl: Schema.Number,
+                type: Schema.Literal("OPENPGPKEY"),
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                comment: "comment",
+                content: "content",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                name: "name",
+                proxiable: "proxiable",
+                proxied: "proxied",
+                settings: "settings",
+                tags: "tags",
+                ttl: "ttl",
+                type: "type",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+        ])),
+        Schema.Null,
+    ])),
+    puts: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Union([
+            Schema.Struct({
+                id: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                proxiable: Schema.Boolean,
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                proxiable: "proxiable",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+            Schema.Struct({
+                id: Schema.String,
+                comment: Schema.String,
+                content: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                name: Schema.String,
+                proxiable: Schema.Boolean,
+                proxied: Schema.Boolean,
+                settings: Schema.Struct({
+                    ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                    ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    ipv4Only: "ipv4_only",
+                    ipv6Only: "ipv6_only",
+                })),
+                tags: Schema.Array(Schema.String),
+                ttl: Schema.Number,
+                type: Schema.Literal("OPENPGPKEY"),
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                comment: "comment",
+                content: "content",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                name: "name",
+                proxiable: "proxiable",
+                proxied: "proxied",
+                settings: "settings",
+                tags: "tags",
+                ttl: "ttl",
+                type: "type",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+        ])),
+        Schema.Null,
+    ])),
+}).pipe(T.ResponsePath("result"));
+export const batchRecord = API.make(() => ({
+    input: BatchRecordRequest,
+    output: BatchRecordResponse,
+    errors: [],
+}));
+export const ExportRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/dns_records/export" }));
+export const ExportRecordResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export const exportRecord = API.make(() => ({
+    input: ExportRecordRequest,
+    output: ExportRecordResponse,
+    errors: [],
+}));
+export const ImportRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    file: Schema.String,
+    proxied: Schema.optional(Schema.String),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/zones/{zone_id}/dns_records/import",
+    contentType: "multipart",
+}));
+export const ImportRecordResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    recsAdded: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    totalRecordsParsed: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    recsAdded: "recs_added",
+    totalRecordsParsed: "total_records_parsed",
+}))
+    .pipe(T.ResponsePath("result"));
+export const importRecord = API.make(() => ({
+    input: ImportRecordRequest,
+    output: ImportRecordResponse,
+    errors: [],
+}));
+export const ScanRecordRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    body: Schema.Unknown.pipe(T.HttpBody()),
+}).pipe(T.Http({ method: "POST", path: "/zones/{zone_id}/dns_records/scan" }));
+export const ScanRecordResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    recsAdded: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    totalRecordsParsed: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    recsAdded: "recs_added",
+    totalRecordsParsed: "total_records_parsed",
+}))
+    .pipe(T.ResponsePath("result"));
+export const scanRecord = API.make(() => ({
+    input: ScanRecordRequest,
+    output: ScanRecordResponse,
+    errors: [],
+}));
+export const ScanReviewRecordRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    accepts: Schema.optional(Schema.Array(Schema.Union([
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("A"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("AAAA"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CNAME"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                flattenCname: Schema.optional(Schema.Boolean),
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                flattenCname: "flatten_cname",
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("MX"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            priority: Schema.optional(Schema.Number),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("NS"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("OPENPGPKEY"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("PTR"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("TXT"),
+            comment: Schema.optional(Schema.String),
+            content: Schema.optional(Schema.String),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CAA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                flags: Schema.optional(Schema.Number),
+                tag: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("CERT"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                certificate: Schema.optional(Schema.String),
+                keyTag: Schema.optional(Schema.Number),
+                type: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                certificate: "certificate",
+                keyTag: "key_tag",
+                type: "type",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("DNSKEY"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                flags: Schema.optional(Schema.Number),
+                protocol: Schema.optional(Schema.Number),
+                publicKey: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                flags: "flags",
+                protocol: "protocol",
+                publicKey: "public_key",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("DS"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                digest: Schema.optional(Schema.String),
+                digestType: Schema.optional(Schema.Number),
+                keyTag: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                digest: "digest",
+                digestType: "digest_type",
+                keyTag: "key_tag",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("HTTPS"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("LOC"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                altitude: Schema.optional(Schema.Number),
+                latDegrees: Schema.optional(Schema.Number),
+                latDirection: Schema.optional(Schema.Literals(["N", "S"])),
+                latMinutes: Schema.optional(Schema.Number),
+                latSeconds: Schema.optional(Schema.Number),
+                longDegrees: Schema.optional(Schema.Number),
+                longDirection: Schema.optional(Schema.Literals(["E", "W"])),
+                longMinutes: Schema.optional(Schema.Number),
+                longSeconds: Schema.optional(Schema.Number),
+                precisionHorz: Schema.optional(Schema.Number),
+                precisionVert: Schema.optional(Schema.Number),
+                size: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                altitude: "altitude",
+                latDegrees: "lat_degrees",
+                latDirection: "lat_direction",
+                latMinutes: "lat_minutes",
+                latSeconds: "lat_seconds",
+                longDegrees: "long_degrees",
+                longDirection: "long_direction",
+                longMinutes: "long_minutes",
+                longSeconds: "long_seconds",
+                precisionHorz: "precision_horz",
+                precisionVert: "precision_vert",
+                size: "size",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("NAPTR"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                flags: Schema.optional(Schema.String),
+                order: Schema.optional(Schema.Number),
+                preference: Schema.optional(Schema.Number),
+                regex: Schema.optional(Schema.String),
+                replacement: Schema.optional(Schema.String),
+                service: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SMIMEA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                certificate: Schema.optional(Schema.String),
+                matchingType: Schema.optional(Schema.Number),
+                selector: Schema.optional(Schema.Number),
+                usage: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                certificate: "certificate",
+                matchingType: "matching_type",
+                selector: "selector",
+                usage: "usage",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SRV"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                port: Schema.optional(Schema.Number),
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                weight: Schema.optional(Schema.Number),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SSHFP"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                algorithm: Schema.optional(Schema.Number),
+                fingerprint: Schema.optional(Schema.String),
+                type: Schema.optional(Schema.Number),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("SVCB"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                priority: Schema.optional(Schema.Number),
+                target: Schema.optional(Schema.String),
+                value: Schema.optional(Schema.String),
+            })),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("TLSA"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                certificate: Schema.optional(Schema.String),
+                matchingType: Schema.optional(Schema.Number),
+                selector: Schema.optional(Schema.Number),
+                usage: Schema.optional(Schema.Number),
+            }).pipe(Schema.encodeKeys({
+                certificate: "certificate",
+                matchingType: "matching_type",
+                selector: "selector",
+                usage: "usage",
+            }))),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            ttl: Schema.Number,
+            type: Schema.Literal("URI"),
+            comment: Schema.optional(Schema.String),
+            data: Schema.optional(Schema.Struct({
+                target: Schema.optional(Schema.String),
+                weight: Schema.optional(Schema.Number),
+            })),
+            priority: Schema.optional(Schema.Number),
+            proxied: Schema.optional(Schema.Boolean),
+            settings: Schema.optional(Schema.Struct({
+                ipv4Only: Schema.optional(Schema.Boolean),
+                ipv6Only: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                ipv4Only: "ipv4_only",
+                ipv6Only: "ipv6_only",
+            }))),
+            tags: Schema.optional(Schema.Array(Schema.String)),
+        }),
+    ]))),
+    rejects: Schema.optional(Schema.Array(Schema.Struct({
+        id: Schema.String,
+    }))),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/zones/{zone_id}/dns_records/scan/review",
+}));
+export const ScanReviewRecordResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accepts: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Union([
+            Schema.Struct({
+                id: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                proxiable: Schema.Boolean,
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                proxiable: "proxiable",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+            Schema.Struct({
+                id: Schema.String,
+                comment: Schema.String,
+                content: Schema.String,
+                createdOn: Schema.String,
+                meta: Schema.Unknown,
+                modifiedOn: Schema.String,
+                name: Schema.String,
+                proxiable: Schema.Boolean,
+                proxied: Schema.Boolean,
+                settings: Schema.Struct({
+                    ipv4Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                    ipv6Only: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    ipv4Only: "ipv4_only",
+                    ipv6Only: "ipv6_only",
+                })),
+                tags: Schema.Array(Schema.String),
+                ttl: Schema.Number,
+                type: Schema.Literal("OPENPGPKEY"),
+                commentModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                tagsModifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                id: "id",
+                comment: "comment",
+                content: "content",
+                createdOn: "created_on",
+                meta: "meta",
+                modifiedOn: "modified_on",
+                name: "name",
+                proxiable: "proxiable",
+                proxied: "proxied",
+                settings: "settings",
+                tags: "tags",
+                ttl: "ttl",
+                type: "type",
+                commentModifiedOn: "comment_modified_on",
+                tagsModifiedOn: "tags_modified_on",
+            })),
+        ])),
+        Schema.Null,
+    ])),
+    rejects: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const scanReviewRecord = API.make(() => ({
+    input: ScanReviewRecordRequest,
+    output: ScanReviewRecordResponse,
+    errors: [],
+}));
+export const GetSettingAccountRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/dns_settings" }));
+export const GetSettingAccountResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneDefaults: Schema.Struct({
+        flattenAllCnames: Schema.Boolean,
+        foundationDns: Schema.Boolean,
+        internalDns: Schema.Struct({
+            referenceZoneId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ referenceZoneId: "reference_zone_id" })),
+        multiProvider: Schema.Boolean,
+        nameservers: Schema.Struct({
+            type: Schema.optional(Schema.Union([
+                Schema.Literals([
+                    "cloudflare.standard",
+                    "cloudflare.standard.random",
+                    "custom.account",
+                    "custom.tenant",
+                ]),
+                Schema.Null,
+            ])),
+        }),
+        nsTtl: Schema.Number,
+        secondaryOverrides: Schema.Boolean,
+        soa: Schema.Struct({
+            expire: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            minTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            mname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            refresh: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            retry: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            rname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            expire: "expire",
+            minTtl: "min_ttl",
+            mname: "mname",
+            refresh: "refresh",
+            retry: "retry",
+            rname: "rname",
+            ttl: "ttl",
+        })),
+        zoneMode: Schema.Literals(["standard", "cdn_only", "dns_only"]),
+    }).pipe(Schema.encodeKeys({
+        flattenAllCnames: "flatten_all_cnames",
+        foundationDns: "foundation_dns",
+        internalDns: "internal_dns",
+        multiProvider: "multi_provider",
+        nameservers: "nameservers",
+        nsTtl: "ns_ttl",
+        secondaryOverrides: "secondary_overrides",
+        soa: "soa",
+        zoneMode: "zone_mode",
+    })),
+})
+    .pipe(Schema.encodeKeys({ zoneDefaults: "zone_defaults" }))
+    .pipe(T.ResponsePath("result"));
+export const getSettingAccount = API.make(() => ({
+    input: GetSettingAccountRequest,
+    output: GetSettingAccountResponse,
+    errors: [],
+}));
+export const PatchSettingAccountRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    zoneDefaults: Schema.optional(Schema.Struct({
+        flattenAllCnames: Schema.optional(Schema.Boolean),
+        foundationDns: Schema.optional(Schema.Boolean),
+        internalDns: Schema.optional(Schema.Struct({
+            referenceZoneId: Schema.optional(Schema.String),
+        }).pipe(Schema.encodeKeys({ referenceZoneId: "reference_zone_id" }))),
+        multiProvider: Schema.optional(Schema.Boolean),
+        nameservers: Schema.optional(Schema.Struct({
+            type: Schema.optional(Schema.Literals([
+                "cloudflare.standard",
+                "cloudflare.standard.random",
+                "custom.account",
+                "custom.tenant",
+            ])),
+        })),
+        nsTtl: Schema.optional(Schema.Number),
+        secondaryOverrides: Schema.optional(Schema.Boolean),
+        soa: Schema.optional(Schema.Struct({
+            expire: Schema.optional(Schema.Number),
+            minTtl: Schema.optional(Schema.Number),
+            mname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            refresh: Schema.optional(Schema.Number),
+            retry: Schema.optional(Schema.Number),
+            rname: Schema.optional(Schema.String),
+            ttl: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({
+            expire: "expire",
+            minTtl: "min_ttl",
+            mname: "mname",
+            refresh: "refresh",
+            retry: "retry",
+            rname: "rname",
+            ttl: "ttl",
+        }))),
+        zoneMode: Schema.optional(Schema.Literals(["standard", "cdn_only", "dns_only"])),
+    }).pipe(Schema.encodeKeys({
+        flattenAllCnames: "flatten_all_cnames",
+        foundationDns: "foundation_dns",
+        internalDns: "internal_dns",
+        multiProvider: "multi_provider",
+        nameservers: "nameservers",
+        nsTtl: "ns_ttl",
+        secondaryOverrides: "secondary_overrides",
+        soa: "soa",
+        zoneMode: "zone_mode",
+    }))),
+}).pipe(Schema.encodeKeys({ zoneDefaults: "zone_defaults" }), T.Http({ method: "PATCH", path: "/accounts/{account_id}/dns_settings" }));
+export const PatchSettingAccountResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneDefaults: Schema.Struct({
+        flattenAllCnames: Schema.Boolean,
+        foundationDns: Schema.Boolean,
+        internalDns: Schema.Struct({
+            referenceZoneId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ referenceZoneId: "reference_zone_id" })),
+        multiProvider: Schema.Boolean,
+        nameservers: Schema.Struct({
+            type: Schema.optional(Schema.Union([
+                Schema.Literals([
+                    "cloudflare.standard",
+                    "cloudflare.standard.random",
+                    "custom.account",
+                    "custom.tenant",
+                ]),
+                Schema.Null,
+            ])),
+        }),
+        nsTtl: Schema.Number,
+        secondaryOverrides: Schema.Boolean,
+        soa: Schema.Struct({
+            expire: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            minTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            mname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            refresh: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            retry: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            rname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            expire: "expire",
+            minTtl: "min_ttl",
+            mname: "mname",
+            refresh: "refresh",
+            retry: "retry",
+            rname: "rname",
+            ttl: "ttl",
+        })),
+        zoneMode: Schema.Literals(["standard", "cdn_only", "dns_only"]),
+    }).pipe(Schema.encodeKeys({
+        flattenAllCnames: "flatten_all_cnames",
+        foundationDns: "foundation_dns",
+        internalDns: "internal_dns",
+        multiProvider: "multi_provider",
+        nameservers: "nameservers",
+        nsTtl: "ns_ttl",
+        secondaryOverrides: "secondary_overrides",
+        soa: "soa",
+        zoneMode: "zone_mode",
+    })),
+})
+    .pipe(Schema.encodeKeys({ zoneDefaults: "zone_defaults" }))
+    .pipe(T.ResponsePath("result"));
+export const patchSettingAccount = API.make(() => ({
+    input: PatchSettingAccountRequest,
+    output: PatchSettingAccountResponse,
+    errors: [],
+}));
+export const GetSettingAccountViewRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    viewId: Schema.String.pipe(T.HttpPath("viewId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/dns_settings/views/{viewId}",
+}));
+export const GetSettingAccountViewResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    createdTime: Schema.String,
+    modifiedTime: Schema.String,
+    name: Schema.String,
+    zones: Schema.Array(Schema.String),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    createdTime: "created_time",
+    modifiedTime: "modified_time",
+    name: "name",
+    zones: "zones",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getSettingAccountView = API.make(() => ({
+    input: GetSettingAccountViewRequest,
+    output: GetSettingAccountViewResponse,
+    errors: [],
+}));
+export const ListSettingAccountViewsRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    direction: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(T.HttpQuery("direction")),
+    match: Schema.optional(Schema.Literals(["any", "all"])).pipe(T.HttpQuery("match")),
+    name: Schema.optional(Schema.Struct({
+        contains: Schema.optional(Schema.String),
+        endswith: Schema.optional(Schema.String),
+        exact: Schema.optional(Schema.String),
+        startswith: Schema.optional(Schema.String),
+    })).pipe(T.HttpQuery("name")),
+    order: Schema.optional(Schema.Literals(["name", "created_on", "modified_on"])).pipe(T.HttpQuery("order")),
+    zoneId: Schema.optional(Schema.String).pipe(T.HttpQuery("zone_id")),
+    zoneName: Schema.optional(Schema.String).pipe(T.HttpQuery("zone_name")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/dns_settings/views",
+}));
+export const ListSettingAccountViewsResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        createdTime: Schema.String,
+        modifiedTime: Schema.String,
+        name: Schema.String,
+        zones: Schema.Array(Schema.String),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        createdTime: "created_time",
+        modifiedTime: "modified_time",
+        name: "name",
+        zones: "zones",
+    }))),
+    resultInfo: Schema.Struct({
+        count: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        page: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        perPage: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        totalCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        count: "count",
+        page: "page",
+        perPage: "per_page",
+        totalCount: "total_count",
+    })),
+}).pipe(Schema.encodeKeys({ result: "result", resultInfo: "result_info" }));
+export const listSettingAccountViews = API.makePaginated(() => ({
+    input: ListSettingAccountViewsRequest,
+    output: ListSettingAccountViewsResponse,
+    errors: [],
+    pagination: {
+        mode: "page",
+        inputToken: "page",
+        outputToken: "resultInfo.page",
+        items: "result",
+        pageSize: "perPage",
+    },
+}));
+export const CreateSettingAccountViewRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.String,
+    zones: Schema.Array(Schema.String),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/dns_settings/views",
+}));
+export const CreateSettingAccountViewResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    createdTime: Schema.String,
+    modifiedTime: Schema.String,
+    name: Schema.String,
+    zones: Schema.Array(Schema.String),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    createdTime: "created_time",
+    modifiedTime: "modified_time",
+    name: "name",
+    zones: "zones",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createSettingAccountView = API.make(() => ({
+    input: CreateSettingAccountViewRequest,
+    output: CreateSettingAccountViewResponse,
+    errors: [],
+}));
+export const PatchSettingAccountViewRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    viewId: Schema.String.pipe(T.HttpPath("viewId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.optional(Schema.String),
+    zones: Schema.optional(Schema.Array(Schema.String)),
+}).pipe(T.Http({
+    method: "PATCH",
+    path: "/accounts/{account_id}/dns_settings/views/{viewId}",
+}));
+export const PatchSettingAccountViewResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    createdTime: Schema.String,
+    modifiedTime: Schema.String,
+    name: Schema.String,
+    zones: Schema.Array(Schema.String),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    createdTime: "created_time",
+    modifiedTime: "modified_time",
+    name: "name",
+    zones: "zones",
+}))
+    .pipe(T.ResponsePath("result"));
+export const patchSettingAccountView = API.make(() => ({
+    input: PatchSettingAccountViewRequest,
+    output: PatchSettingAccountViewResponse,
+    errors: [],
+}));
+export const DeleteSettingAccountViewRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    viewId: Schema.String.pipe(T.HttpPath("viewId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/dns_settings/views/{viewId}",
+}));
+export const DeleteSettingAccountViewResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deleteSettingAccountView = API.make(() => ({
+    input: DeleteSettingAccountViewRequest,
+    output: DeleteSettingAccountViewResponse,
+    errors: [],
+}));
+export const GetSettingZoneRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/dns_settings" }));
+export const GetSettingZoneResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    flattenAllCnames: Schema.Boolean,
+    foundationDns: Schema.Boolean,
+    internalDns: Schema.Struct({
+        referenceZoneId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({ referenceZoneId: "reference_zone_id" })),
+    multiProvider: Schema.Boolean,
+    nameservers: Schema.Struct({
+        type: Schema.Literals([
+            "cloudflare.standard",
+            "custom.account",
+            "custom.tenant",
+            "custom.zone",
+        ]),
+        nsSet: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }).pipe(Schema.encodeKeys({ type: "type", nsSet: "ns_set" })),
+    nsTtl: Schema.Number,
+    secondaryOverrides: Schema.Boolean,
+    soa: Schema.Struct({
+        expire: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        minTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        mname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        refresh: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        retry: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        rname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        expire: "expire",
+        minTtl: "min_ttl",
+        mname: "mname",
+        refresh: "refresh",
+        retry: "retry",
+        rname: "rname",
+        ttl: "ttl",
+    })),
+    zoneMode: Schema.Literals(["standard", "cdn_only", "dns_only"]),
+})
+    .pipe(Schema.encodeKeys({
+    flattenAllCnames: "flatten_all_cnames",
+    foundationDns: "foundation_dns",
+    internalDns: "internal_dns",
+    multiProvider: "multi_provider",
+    nameservers: "nameservers",
+    nsTtl: "ns_ttl",
+    secondaryOverrides: "secondary_overrides",
+    soa: "soa",
+    zoneMode: "zone_mode",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getSettingZone = API.make(() => ({
+    input: GetSettingZoneRequest,
+    output: GetSettingZoneResponse,
+    errors: [],
+}));
+export const PatchSettingZoneRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    flattenAllCnames: Schema.optional(Schema.Boolean),
+    foundationDns: Schema.optional(Schema.Boolean),
+    internalDns: Schema.optional(Schema.Struct({
+        referenceZoneId: Schema.optional(Schema.String),
+    }).pipe(Schema.encodeKeys({ referenceZoneId: "reference_zone_id" }))),
+    multiProvider: Schema.optional(Schema.Boolean),
+    nameservers: Schema.optional(Schema.Struct({
+        nsSet: Schema.optional(Schema.Number),
+        type: Schema.optional(Schema.Literals([
+            "cloudflare.standard",
+            "custom.account",
+            "custom.tenant",
+            "custom.zone",
+        ])),
+    }).pipe(Schema.encodeKeys({ nsSet: "ns_set", type: "type" }))),
+    nsTtl: Schema.optional(Schema.Number),
+    secondaryOverrides: Schema.optional(Schema.Boolean),
+    soa: Schema.optional(Schema.Struct({
+        expire: Schema.optional(Schema.Number),
+        minTtl: Schema.optional(Schema.Number),
+        mname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        refresh: Schema.optional(Schema.Number),
+        retry: Schema.optional(Schema.Number),
+        rname: Schema.optional(Schema.String),
+        ttl: Schema.optional(Schema.Number),
+    }).pipe(Schema.encodeKeys({
+        expire: "expire",
+        minTtl: "min_ttl",
+        mname: "mname",
+        refresh: "refresh",
+        retry: "retry",
+        rname: "rname",
+        ttl: "ttl",
+    }))),
+    zoneMode: Schema.optional(Schema.Literals(["standard", "cdn_only", "dns_only"])),
+}).pipe(Schema.encodeKeys({
+    flattenAllCnames: "flatten_all_cnames",
+    foundationDns: "foundation_dns",
+    internalDns: "internal_dns",
+    multiProvider: "multi_provider",
+    nameservers: "nameservers",
+    nsTtl: "ns_ttl",
+    secondaryOverrides: "secondary_overrides",
+    soa: "soa",
+    zoneMode: "zone_mode",
+}), T.Http({ method: "PATCH", path: "/zones/{zone_id}/dns_settings" }));
+export const PatchSettingZoneResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    flattenAllCnames: Schema.Boolean,
+    foundationDns: Schema.Boolean,
+    internalDns: Schema.Struct({
+        referenceZoneId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({ referenceZoneId: "reference_zone_id" })),
+    multiProvider: Schema.Boolean,
+    nameservers: Schema.Struct({
+        type: Schema.Literals([
+            "cloudflare.standard",
+            "custom.account",
+            "custom.tenant",
+            "custom.zone",
+        ]),
+        nsSet: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }).pipe(Schema.encodeKeys({ type: "type", nsSet: "ns_set" })),
+    nsTtl: Schema.Number,
+    secondaryOverrides: Schema.Boolean,
+    soa: Schema.Struct({
+        expire: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        minTtl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        mname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        refresh: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        retry: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        rname: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        ttl: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        expire: "expire",
+        minTtl: "min_ttl",
+        mname: "mname",
+        refresh: "refresh",
+        retry: "retry",
+        rname: "rname",
+        ttl: "ttl",
+    })),
+    zoneMode: Schema.Literals(["standard", "cdn_only", "dns_only"]),
+})
+    .pipe(Schema.encodeKeys({
+    flattenAllCnames: "flatten_all_cnames",
+    foundationDns: "foundation_dns",
+    internalDns: "internal_dns",
+    multiProvider: "multi_provider",
+    nameservers: "nameservers",
+    nsTtl: "ns_ttl",
+    secondaryOverrides: "secondary_overrides",
+    soa: "soa",
+    zoneMode: "zone_mode",
+}))
+    .pipe(T.ResponsePath("result"));
+export const patchSettingZone = API.make(() => ({
+    input: PatchSettingZoneRequest,
+    output: PatchSettingZoneResponse,
+    errors: [],
+}));
+export const ScanTriggerRecordRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/zones/{zone_id}/dns_records/scan/trigger",
+}));
+export const ScanTriggerRecordResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    errors: Schema.Array(Schema.Struct({
+        code: Schema.Number,
+        message: Schema.String,
+        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        source: Schema.optional(Schema.Union([
+            Schema.Struct({
+                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }),
+            Schema.Null,
+        ])),
+    }).pipe(Schema.encodeKeys({
+        code: "code",
+        message: "message",
+        documentationUrl: "documentation_url",
+        source: "source",
+    }))),
+    messages: Schema.Array(Schema.Struct({
+        code: Schema.Number,
+        message: Schema.String,
+        documentationUrl: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        source: Schema.optional(Schema.Union([
+            Schema.Struct({
+                pointer: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }),
+            Schema.Null,
+        ])),
+    }).pipe(Schema.encodeKeys({
+        code: "code",
+        message: "message",
+        documentationUrl: "documentation_url",
+        source: "source",
+    }))),
+    success: Schema.Literal(true),
+});
+export const scanTriggerRecord = API.make(() => ({
+    input: ScanTriggerRecordRequest,
+    output: ScanTriggerRecordResponse,
+    errors: [],
+}));
+export const GetZoneTransferAclRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    aclId: Schema.String.pipe(T.HttpPath("aclId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/secondary_dns/acls/{aclId}",
+}));
+export const GetZoneTransferAclResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    ipRange: Schema.String,
+    name: Schema.String,
+})
+    .pipe(Schema.encodeKeys({ id: "id", ipRange: "ip_range", name: "name" }))
+    .pipe(T.ResponsePath("result"));
+export const getZoneTransferAcl = API.make(() => ({
+    input: GetZoneTransferAclRequest,
+    output: GetZoneTransferAclResponse,
+    errors: [],
+}));
+export const ListZoneTransferAclsRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/secondary_dns/acls",
+}));
+export const ListZoneTransferAclsResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        ipRange: Schema.String,
+        name: Schema.String,
+    }).pipe(Schema.encodeKeys({ id: "id", ipRange: "ip_range", name: "name" }))),
+});
+export const listZoneTransferAcls = API.makePaginated(() => ({
+    input: ListZoneTransferAclsRequest,
+    output: ListZoneTransferAclsResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const CreateZoneTransferAclRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    ipRange: Schema.String,
+    name: Schema.String,
+}).pipe(Schema.encodeKeys({ ipRange: "ip_range", name: "name" }), T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/secondary_dns/acls",
+}));
+export const CreateZoneTransferAclResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    ipRange: Schema.String,
+    name: Schema.String,
+})
+    .pipe(Schema.encodeKeys({ id: "id", ipRange: "ip_range", name: "name" }))
+    .pipe(T.ResponsePath("result"));
+export const createZoneTransferAcl = API.make(() => ({
+    input: CreateZoneTransferAclRequest,
+    output: CreateZoneTransferAclResponse,
+    errors: [],
+}));
+export const UpdateZoneTransferAclRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    aclId: Schema.String.pipe(T.HttpPath("aclId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    ipRange: Schema.String,
+    name: Schema.String,
+}).pipe(Schema.encodeKeys({ ipRange: "ip_range", name: "name" }), T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/secondary_dns/acls/{aclId}",
+}));
+export const UpdateZoneTransferAclResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    ipRange: Schema.String,
+    name: Schema.String,
+})
+    .pipe(Schema.encodeKeys({ id: "id", ipRange: "ip_range", name: "name" }))
+    .pipe(T.ResponsePath("result"));
+export const updateZoneTransferAcl = API.make(() => ({
+    input: UpdateZoneTransferAclRequest,
+    output: UpdateZoneTransferAclResponse,
+    errors: [],
+}));
+export const DeleteZoneTransferAclRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    aclId: Schema.String.pipe(T.HttpPath("aclId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/secondary_dns/acls/{aclId}",
+}));
+export const DeleteZoneTransferAclResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deleteZoneTransferAcl = API.make(() => ({
+    input: DeleteZoneTransferAclRequest,
+    output: DeleteZoneTransferAclResponse,
+    errors: [],
+}));
+export const CreateZoneTransferForceAxfrRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    body: Schema.Unknown.pipe(T.HttpBody()),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/zones/{zone_id}/secondary_dns/force_axfr",
+}));
+export const CreateZoneTransferForceAxfrResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result"));
+export const createZoneTransferForceAxfr = API.make(() => ({
+    input: CreateZoneTransferForceAxfrRequest,
+    output: CreateZoneTransferForceAxfrResponse,
+    errors: [],
+}));
+export const GetZoneTransferIncomingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/secondary_dns/incoming" }));
+export const GetZoneTransferIncomingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    autoRefreshSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    checkedTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    createdTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    peers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    soaSerial: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    autoRefreshSeconds: "auto_refresh_seconds",
+    checkedTime: "checked_time",
+    createdTime: "created_time",
+    modifiedTime: "modified_time",
+    name: "name",
+    peers: "peers",
+    soaSerial: "soa_serial",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getZoneTransferIncoming = API.make(() => ({
+    input: GetZoneTransferIncomingRequest,
+    output: GetZoneTransferIncomingResponse,
+    errors: [],
+}));
+export const CreateZoneTransferIncomingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    autoRefreshSeconds: Schema.Number,
+    name: Schema.String,
+    peers: Schema.Array(Schema.String),
+}).pipe(Schema.encodeKeys({
+    autoRefreshSeconds: "auto_refresh_seconds",
+    name: "name",
+    peers: "peers",
+}), T.Http({ method: "POST", path: "/zones/{zone_id}/secondary_dns/incoming" }));
+export const CreateZoneTransferIncomingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    autoRefreshSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    checkedTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    createdTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    peers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    soaSerial: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    autoRefreshSeconds: "auto_refresh_seconds",
+    checkedTime: "checked_time",
+    createdTime: "created_time",
+    modifiedTime: "modified_time",
+    name: "name",
+    peers: "peers",
+    soaSerial: "soa_serial",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createZoneTransferIncoming = API.make(() => ({
+    input: CreateZoneTransferIncomingRequest,
+    output: CreateZoneTransferIncomingResponse,
+    errors: [],
+}));
+export const UpdateZoneTransferIncomingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    autoRefreshSeconds: Schema.Number,
+    name: Schema.String,
+    peers: Schema.Array(Schema.String),
+}).pipe(Schema.encodeKeys({
+    autoRefreshSeconds: "auto_refresh_seconds",
+    name: "name",
+    peers: "peers",
+}), T.Http({ method: "PUT", path: "/zones/{zone_id}/secondary_dns/incoming" }));
+export const UpdateZoneTransferIncomingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    autoRefreshSeconds: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    checkedTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    createdTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    peers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    soaSerial: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    autoRefreshSeconds: "auto_refresh_seconds",
+    checkedTime: "checked_time",
+    createdTime: "created_time",
+    modifiedTime: "modified_time",
+    name: "name",
+    peers: "peers",
+    soaSerial: "soa_serial",
+}))
+    .pipe(T.ResponsePath("result"));
+export const updateZoneTransferIncoming = API.make(() => ({
+    input: UpdateZoneTransferIncomingRequest,
+    output: UpdateZoneTransferIncomingResponse,
+    errors: [],
+}));
+export const DeleteZoneTransferIncomingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/zones/{zone_id}/secondary_dns/incoming",
+}));
+export const DeleteZoneTransferIncomingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deleteZoneTransferIncoming = API.make(() => ({
+    input: DeleteZoneTransferIncomingRequest,
+    output: DeleteZoneTransferIncomingResponse,
+    errors: [],
+}));
+export const GetZoneTransferOutgoingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({ method: "GET", path: "/zones/{zone_id}/secondary_dns/outgoing" }));
+export const GetZoneTransferOutgoingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkedTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    createdTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    lastTransferredTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    peers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    soaSerial: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    checkedTime: "checked_time",
+    createdTime: "created_time",
+    lastTransferredTime: "last_transferred_time",
+    name: "name",
+    peers: "peers",
+    soaSerial: "soa_serial",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getZoneTransferOutgoing = API.make(() => ({
+    input: GetZoneTransferOutgoingRequest,
+    output: GetZoneTransferOutgoingResponse,
+    errors: [],
+}));
+export const CreateZoneTransferOutgoingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    name: Schema.String,
+    peers: Schema.Array(Schema.String),
+}).pipe(T.Http({ method: "POST", path: "/zones/{zone_id}/secondary_dns/outgoing" }));
+export const CreateZoneTransferOutgoingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkedTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    createdTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    lastTransferredTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    peers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    soaSerial: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    checkedTime: "checked_time",
+    createdTime: "created_time",
+    lastTransferredTime: "last_transferred_time",
+    name: "name",
+    peers: "peers",
+    soaSerial: "soa_serial",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createZoneTransferOutgoing = API.make(() => ({
+    input: CreateZoneTransferOutgoingRequest,
+    output: CreateZoneTransferOutgoingResponse,
+    errors: [],
+}));
+export const UpdateZoneTransferOutgoingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    name: Schema.String,
+    peers: Schema.Array(Schema.String),
+}).pipe(T.Http({ method: "PUT", path: "/zones/{zone_id}/secondary_dns/outgoing" }));
+export const UpdateZoneTransferOutgoingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    checkedTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    createdTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    lastTransferredTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    peers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    soaSerial: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    checkedTime: "checked_time",
+    createdTime: "created_time",
+    lastTransferredTime: "last_transferred_time",
+    name: "name",
+    peers: "peers",
+    soaSerial: "soa_serial",
+}))
+    .pipe(T.ResponsePath("result"));
+export const updateZoneTransferOutgoing = API.make(() => ({
+    input: UpdateZoneTransferOutgoingRequest,
+    output: UpdateZoneTransferOutgoingResponse,
+    errors: [],
+}));
+export const DeleteZoneTransferOutgoingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/zones/{zone_id}/secondary_dns/outgoing",
+}));
+export const DeleteZoneTransferOutgoingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deleteZoneTransferOutgoing = API.make(() => ({
+    input: DeleteZoneTransferOutgoingRequest,
+    output: DeleteZoneTransferOutgoingResponse,
+    errors: [],
+}));
+export const EnableZoneTransferOutgoingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    body: Schema.Unknown.pipe(T.HttpBody()),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/zones/{zone_id}/secondary_dns/outgoing/enable",
+}));
+export const EnableZoneTransferOutgoingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result"));
+export const enableZoneTransferOutgoing = API.make(() => ({
+    input: EnableZoneTransferOutgoingRequest,
+    output: EnableZoneTransferOutgoingResponse,
+    errors: [],
+}));
+export const DisableZoneTransferOutgoingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+    body: Schema.Unknown.pipe(T.HttpBody()),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/zones/{zone_id}/secondary_dns/outgoing/disable",
+}));
+export const DisableZoneTransferOutgoingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.String.pipe(T.ResponsePath("result"));
+export const disableZoneTransferOutgoing = API.make(() => ({
+    input: DisableZoneTransferOutgoingRequest,
+    output: DisableZoneTransferOutgoingResponse,
+    errors: [],
+}));
+export const GetZoneTransferOutgoingStatusRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    zoneId: Schema.String.pipe(T.HttpPath("zone_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/zones/{zone_id}/secondary_dns/outgoing/status",
+}));
+export const GetZoneTransferOutgoingStatusResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export const getZoneTransferOutgoingStatus = API.make(() => ({
+    input: GetZoneTransferOutgoingStatusRequest,
+    output: GetZoneTransferOutgoingStatusResponse,
+    errors: [],
+}));
+export const GetZoneTransferPeerRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    peerId: Schema.String.pipe(T.HttpPath("peerId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/secondary_dns/peers/{peerId}",
+}));
+export const GetZoneTransferPeerResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    ip: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    ixfrEnable: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    tsigId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    name: "name",
+    ip: "ip",
+    ixfrEnable: "ixfr_enable",
+    port: "port",
+    tsigId: "tsig_id",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getZoneTransferPeer = API.make(() => ({
+    input: GetZoneTransferPeerRequest,
+    output: GetZoneTransferPeerResponse,
+    errors: [],
+}));
+export const ListZoneTransferPeersRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/secondary_dns/peers",
+}));
+export const ListZoneTransferPeersResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        name: Schema.String,
+        ip: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        ixfrEnable: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+        port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        tsigId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        id: "id",
+        name: "name",
+        ip: "ip",
+        ixfrEnable: "ixfr_enable",
+        port: "port",
+        tsigId: "tsig_id",
+    }))),
+});
+export const listZoneTransferPeers = API.makePaginated(() => ({
+    input: ListZoneTransferPeersRequest,
+    output: ListZoneTransferPeersResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const CreateZoneTransferPeerRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.String,
+}).pipe(T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/secondary_dns/peers",
+}));
+export const CreateZoneTransferPeerResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    ip: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    ixfrEnable: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    tsigId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    name: "name",
+    ip: "ip",
+    ixfrEnable: "ixfr_enable",
+    port: "port",
+    tsigId: "tsig_id",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createZoneTransferPeer = API.make(() => ({
+    input: CreateZoneTransferPeerRequest,
+    output: CreateZoneTransferPeerResponse,
+    errors: [],
+}));
+export const UpdateZoneTransferPeerRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    peerId: Schema.String.pipe(T.HttpPath("peerId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.String,
+    ip: Schema.optional(Schema.String),
+    ixfrEnable: Schema.optional(Schema.Boolean),
+    port: Schema.optional(Schema.Number),
+    tsigId: Schema.optional(Schema.String),
+}).pipe(Schema.encodeKeys({
+    name: "name",
+    ip: "ip",
+    ixfrEnable: "ixfr_enable",
+    port: "port",
+    tsigId: "tsig_id",
+}), T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/secondary_dns/peers/{peerId}",
+}));
+export const UpdateZoneTransferPeerResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    ip: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    ixfrEnable: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    port: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    tsigId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    id: "id",
+    name: "name",
+    ip: "ip",
+    ixfrEnable: "ixfr_enable",
+    port: "port",
+    tsigId: "tsig_id",
+}))
+    .pipe(T.ResponsePath("result"));
+export const updateZoneTransferPeer = API.make(() => ({
+    input: UpdateZoneTransferPeerRequest,
+    output: UpdateZoneTransferPeerResponse,
+    errors: [],
+}));
+export const DeleteZoneTransferPeerRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    peerId: Schema.String.pipe(T.HttpPath("peerId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/secondary_dns/peers/{peerId}",
+}));
+export const DeleteZoneTransferPeerResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deleteZoneTransferPeer = API.make(() => ({
+    input: DeleteZoneTransferPeerRequest,
+    output: DeleteZoneTransferPeerResponse,
+    errors: [],
+}));
+export const GetZoneTransferTsigRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    tsigId: Schema.String.pipe(T.HttpPath("tsigId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/secondary_dns/tsigs/{tsigId}",
+}));
+export const GetZoneTransferTsigResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    algo: Schema.String,
+    name: Schema.String,
+    secret: Schema.String,
+}).pipe(T.ResponsePath("result"));
+export const getZoneTransferTsig = API.make(() => ({
+    input: GetZoneTransferTsigRequest,
+    output: GetZoneTransferTsigResponse,
+    errors: [],
+}));
+export const ListZoneTransferTsigsRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/secondary_dns/tsigs",
+}));
+export const ListZoneTransferTsigsResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        algo: Schema.String,
+        name: Schema.String,
+        secret: SensitiveString,
+    })),
+});
+export const listZoneTransferTsigs = API.makePaginated(() => ({
+    input: ListZoneTransferTsigsRequest,
+    output: ListZoneTransferTsigsResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const CreateZoneTransferTsigRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    algo: Schema.String,
+    name: Schema.String,
+    secret: Schema.String,
+}).pipe(T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/secondary_dns/tsigs",
+}));
+export const CreateZoneTransferTsigResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    algo: Schema.String,
+    name: Schema.String,
+    secret: Schema.String,
+}).pipe(T.ResponsePath("result"));
+export const createZoneTransferTsig = API.make(() => ({
+    input: CreateZoneTransferTsigRequest,
+    output: CreateZoneTransferTsigResponse,
+    errors: [],
+}));
+export const UpdateZoneTransferTsigRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    tsigId: Schema.String.pipe(T.HttpPath("tsigId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    algo: Schema.String,
+    name: Schema.String,
+    secret: Schema.String,
+}).pipe(T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/secondary_dns/tsigs/{tsigId}",
+}));
+export const UpdateZoneTransferTsigResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    algo: Schema.String,
+    name: Schema.String,
+    secret: Schema.String,
+}).pipe(T.ResponsePath("result"));
+export const updateZoneTransferTsig = API.make(() => ({
+    input: UpdateZoneTransferTsigRequest,
+    output: UpdateZoneTransferTsigResponse,
+    errors: [],
+}));
+export const DeleteZoneTransferTsigRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    tsigId: Schema.String.pipe(T.HttpPath("tsigId")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/secondary_dns/tsigs/{tsigId}",
+}));
+export const DeleteZoneTransferTsigResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const deleteZoneTransferTsig = API.make(() => ({
+    input: DeleteZoneTransferTsigRequest,
+    output: DeleteZoneTransferTsigResponse,
+    errors: [],
+}));
+//# sourceMappingURL=dns.js.map