@sdxc/zone-file 2026.10.13 → 2026.11.3

package/dist/cli.d.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * The `sdxc-zone-file` command-line program: the contract in `cli-contract.ts` with each command
+ * mapped onto its handler, which loads only when that command runs. Exit codes: 0 done, 1 the
+ * zone file has entries it could not use, 2 usage or unreadable input.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/** The `sdxc-zone-file` program, run by the bin entry below and by tests through `invoke()`. */
+export declare const cli: import("@sdxc/cli").CLI<import("@sdxc/cli").Group<Omit<{
+    readonly description: "sdxc-zone-file — read, check and write RFC 1035 DNS zone files";
+    readonly validate: import("@sdxc/cli").Command<{
+        readonly zone: import("@sdxc/cli").Argument<string>;
+    }, {
+        readonly origin: import("@sdxc/cli").ValueFlag<string, true, false, false>;
+        readonly ttl: import("@sdxc/cli").ValueFlag<number, false, false, false>;
+        readonly json: import("@sdxc/cli").Flag<boolean>;
+    }>;
+    readonly parse: import("@sdxc/cli").Command<{
+        readonly zone: import("@sdxc/cli").Argument<string>;
+    }, {
+        readonly origin: import("@sdxc/cli").ValueFlag<string, true, false, false>;
+        readonly ttl: import("@sdxc/cli").ValueFlag<number, false, false, false>;
+        readonly json: import("@sdxc/cli").Flag<boolean>;
+    }>;
+    readonly format: import("@sdxc/cli").Command<{
+        readonly input: import("@sdxc/cli").Argument<string>;
+    }, {
+        readonly origin: import("@sdxc/cli").ValueFlag<string, true, false, false>;
+        readonly ttl: import("@sdxc/cli").ValueFlag<number, false, false, false>;
+        readonly relative: import("@sdxc/cli").Flag<boolean>;
+    }>;
+}, "description" | "hidden" | "arguments" | "flags" | "tasks">, Record<never, never>, Record<never, never>>, []>;

package/dist/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * The `sdxc-zone-file` command-line program: the contract in `cli-contract.ts` with each command
+ * mapped onto its handler, which loads only when that command runs. Exit codes: 0 done, 1 the
+ * zone file has entries it could not use, 2 usage or unreadable input.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import { createCLI, lazy } from "@sdxc/cli";
+import { ZONE_FILE_COMMANDS } from "./cli-contract.js";
+/** The `sdxc-zone-file` program, run by the bin entry below and by tests through `invoke()`. */
+export const cli = createCLI({ name: "sdxc-zone-file", commands: ZONE_FILE_COMMANDS });
+cli.map(ZONE_FILE_COMMANDS.validate, lazy(() => import("./cli-validate.js")));
+cli.map(ZONE_FILE_COMMANDS.parse, lazy(() => import("./cli-parse.js")));
+cli.map(ZONE_FILE_COMMANDS.format, lazy(() => import("./cli-format.js")));
+if (import.meta.main) {
+    process.exit(await cli.run(process.argv.slice(2)));
+}

package/dist/dnssec.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The DNSSEC pieces DS and DNSKEY data share: the algorithm mnemonics RFC 4034 lets a zone
+ * file write in place of a number, and the key tag a DS record names its DNSKEY by, so a
+ * delegation's DS set can be matched against the child's keys.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/** An algorithm field as a number, read from its decimal or its mnemonic; `null` for neither. */
+export declare function readAlgorithm(field: string | undefined): number | null;
+/**
+ * The key tag of DNSKEY RDATA (RFC 4034 Appendix B): the octets summed as big-endian 16-bit
+ * words with the carry folded back in once, and for an RSA/MD5 (algorithm 1) key the
+ * modulus's second- and third-to-last octets, as that appendix specifies for it.
+ *
+ * @param rdata - The DNSKEY RDATA in wire form: flags, protocol, algorithm and key.
+ */
+export declare function keyTag(rdata: Uint8Array): number;

package/dist/dnssec.js

@@ -0,0 +1,53 @@
+/**
+ * The DNSSEC pieces DS and DNSKEY data share: the algorithm mnemonics RFC 4034 lets a zone
+ * file write in place of a number, and the key tag a DS record names its DNSKEY by, so a
+ * delegation's DS set can be matched against the child's keys.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/** The DNSSEC algorithm numbers by IANA mnemonic; the uppercase mnemonic reads as its number. */
+const ALGORITHMS = {
+    RSAMD5: 1,
+    DH: 2,
+    DSA: 3,
+    RSASHA1: 5,
+    "DSA-NSEC3-SHA1": 6,
+    "RSASHA1-NSEC3-SHA1": 7,
+    RSASHA256: 8,
+    RSASHA512: 10,
+    "ECC-GOST": 12,
+    ECDSAP256SHA256: 13,
+    ECDSAP384SHA384: 14,
+    ED25519: 15,
+    ED448: 16,
+    INDIRECT: 252,
+    PRIVATEDNS: 253,
+    PRIVATEOID: 254,
+};
+/** An algorithm field as a number, read from its decimal or its mnemonic; `null` for neither. */
+export function readAlgorithm(field) {
+    if (field === undefined)
+        return null;
+    if (/^\d+$/.test(field)) {
+        let number = Number(field);
+        return number <= 0xff ? number : null;
+    }
+    return ALGORITHMS[field.toUpperCase()] ?? null;
+}
+/**
+ * The key tag of DNSKEY RDATA (RFC 4034 Appendix B): the octets summed as big-endian 16-bit
+ * words with the carry folded back in once, and for an RSA/MD5 (algorithm 1) key the
+ * modulus's second- and third-to-last octets, as that appendix specifies for it.
+ *
+ * @param rdata - The DNSKEY RDATA in wire form: flags, protocol, algorithm and key.
+ */
+export function keyTag(rdata) {
+    if (rdata[3] === 1 && rdata.length >= 7)
+        return ((rdata[rdata.length - 3] ?? 0) << 8) | (rdata[rdata.length - 2] ?? 0);
+    let sum = 0;
+    for (let index = 0; index < rdata.length; index++)
+        sum += index % 2 === 0 ? (rdata[index] ?? 0) << 8 : (rdata[index] ?? 0);
+    sum += (sum >> 16) & 0xffff;
+    return sum & 0xffff;
+}

package/dist/format-record-data.d.ts

@@ -8,10 +8,9 @@
  */
 import type * as ZoneFile from "./types.js";
 /**
- * Prints a record's data in canonical presentation format. Names print absolute with the
- * trailing dot (the root stays `"."`), TXT and CAA values print quoted with `"` and `\`
- * escaped and every octet outside printable ASCII as `\DDD`, and untyped data prints as is.
- * `parseRecordData(data.type, formatRecordData(data))` gives back `data`.
+ * Prints a record's data in canonical presentation format: names absolute, free text quoted
+ * with every octet outside printable ASCII as `\DDD`, hex lowercase, SvcParams in key order,
+ * untyped data as is. `parseRecordData(data.type, formatRecordData(data))` gives back `data`.
  *
  * @param data - Record data, as `parseRecordData` produces it.
  * @returns The RDATA in presentation format.

package/dist/format-record-data.js

@@ -1,11 +1,11 @@
 import { absoluteName } from "./names.js";
+import { printSvcParams } from "./svc-params.js";
 /** Encodes a character-string into the octets `\DDD` escapes stand for. */
 const ENCODER = new TextEncoder();
 /**
- * Prints a record's data in canonical presentation format. Names print absolute with the
- * trailing dot (the root stays `"."`), TXT and CAA values print quoted with `"` and `\`
- * escaped and every octet outside printable ASCII as `\DDD`, and untyped data prints as is.
- * `parseRecordData(data.type, formatRecordData(data))` gives back `data`.
+ * Prints a record's data in canonical presentation format: names absolute, free text quoted
+ * with every octet outside printable ASCII as `\DDD`, hex lowercase, SvcParams in key order,
+ * untyped data as is. `parseRecordData(data.type, formatRecordData(data))` gives back `data`.
  *
  * @param data - Record data, as `parseRecordData` produces it.
  * @returns The RDATA in presentation format.
@@ -62,6 +62,26 @@ export function printRecordData(data, printName) {
                 soa.minimum,
             ].join(" ");
         }
+        case "SVCB":
+        case "HTTPS": {
+            let { priority, target, params } = data;
+            let printed = printSvcParams(params, quote);
+            return `${priority} ${printName(target)}${printed ? ` ${printed}` : ""}`;
+        }
+        case "TLSA": {
+            let tlsa = data;
+            return `${tlsa.usage} ${tlsa.selector} ${tlsa.matchingType} ${tlsa.certificateAssociation}`;
+        }
+        case "DS":
+        case "CDS": {
+            let ds = data;
+            return `${ds.keyTag} ${ds.algorithm} ${ds.digestType} ${ds.digest}`;
+        }
+        case "DNSKEY":
+        case "CDNSKEY": {
+            let key = data;
+            return `${key.flags} ${key.protocol} ${key.algorithm} ${key.publicKey}`;
+        }
         default:
             return String(data.data);
     }

package/dist/index.d.ts

@@ -12,5 +12,5 @@ export { RecordDataError, ZoneFileError } from "./errors.js";
 export { formatRecordData } from "./format-record-data.js";
 export { parse } from "./parse.js";
 export { parseRecordData } from "./parse-record-data.js";
-export { canonicalType, typeName } from "./record-types.js";
+export { canonicalType, typeCode, typeName } from "./record-types.js";
 export { stringify } from "./stringify.js";

package/dist/index.js

@@ -10,5 +10,5 @@ export { RecordDataError, ZoneFileError } from "./errors.js";
 export { formatRecordData } from "./format-record-data.js";
 export { parse } from "./parse.js";
 export { parseRecordData } from "./parse-record-data.js";
-export { canonicalType, typeName } from "./record-types.js";
+export { canonicalType, typeCode, typeName } from "./record-types.js";
 export { stringify } from "./stringify.js";

package/dist/octets.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Hex and base64 codecs for the binary fields of DNSSEC, DANE and SVCB records, which the
+ * presentation format writes as text a zone file may split across whitespace and lines.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/** The octets a hex string spells, whitespace ignored; `null` for an odd or non-hex run, or none. */
+export declare function decodeHex(text: string): Uint8Array | null;
+/** Octets as lowercase hex, the spelling DS digests and TLSA data compare in. */
+export declare function encodeHex(octets: Uint8Array): string;
+/** The octets a base64 string spells, whitespace ignored; `null` for text that is not base64, or none. */
+export declare function decodeBase64(text: string): Uint8Array | null;
+/** Octets as padded base64, the spelling DNSKEY keys and SVCB `ech` print in. */
+export declare function encodeBase64(octets: Uint8Array): string;

package/dist/octets.js

@@ -0,0 +1,37 @@
+/**
+ * Hex and base64 codecs for the binary fields of DNSSEC, DANE and SVCB records, which the
+ * presentation format writes as text a zone file may split across whitespace and lines.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/** Hex text in pairs, with any whitespace between digits already removed. */
+const HEX_PATTERN = /^(?:[0-9a-fA-F]{2})+$/;
+/** Canonical base64: complete quads, padding only at the end. */
+const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+/** The octets a hex string spells, whitespace ignored; `null` for an odd or non-hex run, or none. */
+export function decodeHex(text) {
+    let hex = text.replace(/\s+/g, "");
+    if (!HEX_PATTERN.test(hex))
+        return null;
+    let octets = new Uint8Array(hex.length / 2);
+    for (let index = 0; index < octets.length; index++)
+        octets[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+    return octets;
+}
+/** Octets as lowercase hex, the spelling DS digests and TLSA data compare in. */
+export function encodeHex(octets) {
+    return Array.from(octets, (octet) => octet.toString(16).padStart(2, "0")).join("");
+}
+/** The octets a base64 string spells, whitespace ignored; `null` for text that is not base64, or none. */
+export function decodeBase64(text) {
+    let base64 = text.replace(/\s+/g, "");
+    if (base64.length === 0 || !BASE64_PATTERN.test(base64))
+        return null;
+    let binary = atob(base64);
+    return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+}
+/** Octets as padded base64, the spelling DNSKEY keys and SVCB `ech` print in. */
+export function encodeBase64(octets) {
+    return btoa(Array.from(octets, (octet) => String.fromCharCode(octet)).join(""));
+}

package/dist/parse-record-data.js

@@ -1,14 +1,13 @@
 import { failure, isFailure, success } from "@sdxc/result";
+import { canonicalIpv6, isIpv4, printIpv6 } from "./addresses.js";
 import { decodeOctets, readCharacterStrings } from "./character-strings.js";
+import { keyTag, readAlgorithm } from "./dnssec.js";
 import { RecordDataError } from "./errors.js";
 import { canonicalName, printLabels } from "./names.js";
+import { decodeBase64, decodeHex, encodeBase64, encodeHex } from "./octets.js";
 import { canonicalType } from "./record-types.js";
+import { readSvcParams, readWireSvcParams } from "./svc-params.js";
 import { readTtl } from "./ttl.js";
-/**
- * A dotted-quad IPv4 address without leading zeros, which `inet_aton` would read as octal
- * and browsers as decimal, so an address carrying them has no single meaning.
- */
-const IPV4_PATTERN = /^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
 /**
  * Reads a record's data into its typed fields; untyped types come back as `{ type, data }`.
  * Names come back canonical (lowercased, escapes resolved, no trailing dot, the root as
@@ -39,19 +38,41 @@ function readNumber(field, max) {
     let number = Number(field);
     return number <= max ? number : null;
 }
-/** An IPv6 literal in RFC 5952 canonical form, or `null` when the text is not one. */
-function canonicalIpv6(value) {
-    if (!value.includes(":"))
-        return null;
-    let url = URL.parse(`http://[${value}]/`);
-    return url ? url.hostname.slice(1, -1) : null;
+/**
+ * The fields of DNSKEY data from its wire octets, the key tag computed over them, so the
+ * presentation and generic spellings of one key agree on every field.
+ */
+function dnskeyFields(rdata) {
+    let flags = ((rdata[0] ?? 0) << 8) | (rdata[1] ?? 0);
+    return {
+        flags,
+        zoneKey: (flags & 0x0100) !== 0,
+        secureEntryPoint: (flags & 0x0001) !== 0,
+        protocol: rdata[2] ?? 0,
+        algorithm: rdata[3] ?? 0,
+        publicKey: encodeBase64(rdata.subarray(4)),
+        keyTag: keyTag(rdata),
+    };
+}
+/** Reads the leading `count` whitespace-separated fields and the rest of the text after them. */
+function splitLeading(value, count) {
+    let fields = [];
+    let rest = value;
+    for (let index = 0; index < count; index++) {
+        let match = /^(\S+)\s*/.exec(rest);
+        if (!match)
+            break;
+        fields.push(match[1] ?? "");
+        rest = rest.slice(match[0].length);
+    }
+    return [fields, rest];
 }
 /** Reads presentation-format data for the typed record types. */
 function parsePresentation(type, value) {
     let fields = value.split(/\s+/).filter((field) => field.length > 0);
     switch (type) {
         case "A":
-            return IPV4_PATTERN.test(value) ? success({ type, address: value }) : invalid(type, value);
+            return isIpv4(value) ? success({ type, address: value }) : invalid(type, value);
         case "AAAA": {
             let address = canonicalIpv6(value);
             return address ? success({ type, address }) : invalid(type, value);
@@ -133,6 +154,50 @@ function parsePresentation(type, value) {
                 minimum,
             });
         }
+        case "SVCB":
+        case "HTTPS": {
+            let [[priorityField, targetField], rest] = splitLeading(value, 2);
+            let priority = readNumber(priorityField, 0xffff);
+            let target = targetField === undefined ? null : canonicalName(targetField);
+            let params = readSvcParams(rest);
+            if (priority === null || target === null || params === null)
+                return invalid(type, value);
+            return success({ type, priority, target, params });
+        }
+        case "TLSA": {
+            let [leading, rest] = splitLeading(value, 3);
+            let [usage, selector, matchingType] = leading.map((field) => readNumber(field, 0xff));
+            let association = decodeHex(rest);
+            if (usage == null || selector == null || matchingType == null || !association)
+                return invalid(type, value);
+            let certificateAssociation = encodeHex(association);
+            return success({ type, usage, selector, matchingType, certificateAssociation });
+        }
+        case "DS":
+        case "CDS": {
+            let [[tagField, algorithmField, digestTypeField], rest] = splitLeading(value, 3);
+            let keyTag = readNumber(tagField, 0xffff);
+            let algorithm = readAlgorithm(algorithmField);
+            let digestType = readNumber(digestTypeField, 0xff);
+            let digest = decodeHex(rest);
+            if (keyTag === null || algorithm === null || digestType === null || !digest)
+                return invalid(type, value);
+            return success({ type, keyTag, algorithm, digestType, digest: encodeHex(digest) });
+        }
+        case "DNSKEY":
+        case "CDNSKEY": {
+            let [[flagsField, protocolField, algorithmField], rest] = splitLeading(value, 3);
+            let flags = readNumber(flagsField, 0xffff);
+            let protocol = readNumber(protocolField, 0xff);
+            let algorithm = readAlgorithm(algorithmField);
+            let key = decodeBase64(rest);
+            if (flags === null || protocol === null || algorithm === null || !key)
+                return invalid(type, value);
+            let rdata = new Uint8Array(4 + key.length);
+            rdata.set([flags >> 8, flags & 0xff, protocol, algorithm]);
+            rdata.set(key, 4);
+            return success({ type, ...dnskeyFields(rdata) });
+        }
         default:
             return success({ type, data: value });
     }
@@ -187,10 +252,7 @@ class WireReader {
             }
             case "AAAA": {
                 let bytes = this.#bytes(16);
-                if (!bytes)
-                    return null;
-                let groups = Array.from({ length: 8 }, (_, index) => (((bytes[index * 2] ?? 0) << 8) | (bytes[index * 2 + 1] ?? 0)).toString(16));
-                return { address: canonicalIpv6(groups.join(":")) ?? groups.join(":") };
+                return bytes ? { address: printIpv6(bytes) } : null;
             }
             case "CNAME":
             case "PTR":
@@ -250,6 +312,39 @@ class WireReader {
                 let [serial, refresh, retry, expire, minimum] = numbers;
                 return { primary, mailbox, serial, refresh, retry, expire, minimum };
             }
+            case "SVCB":
+            case "HTTPS": {
+                let priority = this.#uint(2);
+                let target = this.#name();
+                let params = readWireSvcParams(this.#rest());
+                if (priority === null || target === null || params === null)
+                    return null;
+                return { priority, target, params };
+            }
+            case "TLSA": {
+                let [usage, selector, matchingType] = [this.#uint(1), this.#uint(1), this.#uint(1)];
+                let association = this.#rest();
+                if (usage === null || selector === null || matchingType === null)
+                    return null;
+                if (association.length === 0)
+                    return null;
+                return { usage, selector, matchingType, certificateAssociation: encodeHex(association) };
+            }
+            case "DS":
+            case "CDS": {
+                let [keyTag, algorithm, digestType] = [this.#uint(2), this.#uint(1), this.#uint(1)];
+                let digest = this.#rest();
+                if (keyTag === null || algorithm === null || digestType === null)
+                    return null;
+                if (digest.length === 0)
+                    return null;
+                return { keyTag, algorithm, digestType, digest: encodeHex(digest) };
+            }
+            case "DNSKEY":
+            case "CDNSKEY": {
+                let rdata = this.#rest();
+                return rdata.length > 4 ? dnskeyFields(rdata) : null;
+            }
             default:
                 return "unknown";
         }
@@ -262,6 +357,10 @@ class WireReader {
         this.#offset += length;
         return bytes;
     }
+    /** Every octet left, which the types ending in a variable-length field read as that field. */
+    #rest() {
+        return this.#bytes(this.#octets.length - this.#offset) ?? new Uint8Array();
+    }
     /** A big-endian unsigned integer of `size` octets. */
     #uint(size) {
         let bytes = this.#bytes(size);

package/dist/parse.js

@@ -20,6 +20,8 @@ const NAME_FIELDS = {
     MX: [1],
     SRV: [3],
     SOA: [0, 1],
+    SVCB: [1],
+    HTTPS: [1],
 };
 /** The class numbers with a mnemonic, so `CLASS1` and `IN` read as one class. */
 const CLASS_NAMES = { "1": "IN", "2": "CS", "3": "CH", "4": "HS" };

package/dist/record-types.d.ts

@@ -8,6 +8,14 @@
 import type * as ZoneFile from "./types.js";
 /** The mnemonic for a type code, or `TYPEnnn` when it has none here. */
 export declare function typeName(code: number): string;
+/**
+ * The IANA code of a type, given as a mnemonic or `TYPEnnn`, so a caller building a query
+ * message can name the type the way a zone file does; `null` for a mnemonic it does not know.
+ *
+ * @example typeCode("HTTPS") // 65
+ * @example typeCode("TYPE65280") // 65280
+ */
+export declare function typeCode(type: string): number | null;
 /**
  * The spelling of a type as a record's `type`: the uppercase mnemonic, and a known
  * mnemonic for `TYPEnnn` when one exists.

package/dist/record-types.js

@@ -43,6 +43,13 @@ const TYPED_TYPES = new Set([
     "CAA",
     "SRV",
     "SOA",
+    "SVCB",
+    "HTTPS",
+    "TLSA",
+    "DS",
+    "CDS",
+    "DNSKEY",
+    "CDNSKEY",
 ]);
 /** The mnemonic for each code in {@link TYPE_CODES}. */
 const TYPE_NAMES = new Map(Object.entries(TYPE_CODES).map(([name, code]) => [code, name]));
@@ -50,6 +57,22 @@ const TYPE_NAMES = new Map(Object.entries(TYPE_CODES).map(([name, code]) => [cod
 export function typeName(code) {
     return TYPE_NAMES.get(code) ?? `TYPE${code}`;
 }
+/**
+ * The IANA code of a type, given as a mnemonic or `TYPEnnn`, so a caller building a query
+ * message can name the type the way a zone file does; `null` for a mnemonic it does not know.
+ *
+ * @example typeCode("HTTPS") // 65
+ * @example typeCode("TYPE65280") // 65280
+ */
+export function typeCode(type) {
+    let upper = type.trim().toUpperCase();
+    let generic = /^TYPE(\d{1,5})$/.exec(upper);
+    if (generic) {
+        let code = Number(generic[1]);
+        return code <= 0xffff ? code : null;
+    }
+    return TYPE_CODES[upper] ?? null;
+}
 /**
  * The spelling of a type as a record's `type`: the uppercase mnemonic, and a known
  * mnemonic for `TYPEnnn` when one exists.

package/dist/svc-params.d.ts

@@ -0,0 +1,24 @@
+import type * as ZoneFile from "./types.js";
+/**
+ * Reads the params of SVCB or HTTPS presentation data, the fields after the target.
+ * Fails on an unknown or repeated key and on a value its key does not accept.
+ *
+ * @param text - Zero or more `key[=value]` fields.
+ */
+export declare function readSvcParams(text: string): ZoneFile.SvcParams | null;
+/**
+ * Reads the params of SVCB or HTTPS wire data, the octets after the target. Keys must
+ * strictly increase, as RFC 9460 requires of the wire form.
+ *
+ * @param octets - The SvcParams octets, `key length value` repeated.
+ */
+export declare function readWireSvcParams(octets: Uint8Array): ZoneFile.SvcParams | null;
+/**
+ * Prints params in canonical presentation form, keys in ascending number order and values
+ * quoted wherever they are free text, so two spellings of one record print alike.
+ *
+ * @param params - The params to print.
+ * @param quote - Prints a character-string with its escapes.
+ * @returns The fields joined by spaces; empty for no params.
+ */
+export declare function printSvcParams(params: ZoneFile.SvcParams, quote: (text: string) => string): string;