@lox-audioserver/node-airplay-sender 0.4.0

package/dist/esm/utils/http.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_net_1 = __importDefault(require("node:net"));
+const HttpMessage = (parseStartLine, writeStartLine) => {
+    const instance = {
+        parse: () => ({ headers: {} }),
+        write: () => Buffer.alloc(0),
+    };
+    instance.parse = (buffer) => {
+        const messageObject = { headers: {} };
+        // ...
+        let bodyIndex = buffer.indexOf('\r\n\r\n');
+        let headerString = buffer.slice(0, bodyIndex).toString();
+        let body = buffer.slice(bodyIndex + 4);
+        headerString = headerString.replace(/\r\n/g, '\n');
+        const lines = headerString.split('\n');
+        bodyIndex += 2;
+        // ...
+        let line = lines.shift();
+        if (line) {
+            parseStartLine(line, messageObject);
+        }
+        // ...
+        line = lines.shift();
+        while (line) {
+            const headerName = line.substr(0, line.indexOf(':'));
+            const headerValue = line.substr(line.indexOf(':') + 1);
+            messageObject.headers[headerName] = headerValue.trim();
+            line = lines.shift();
+        }
+        // ...
+        if (messageObject.headers['Content-Length'] && messageObject.headers['Content-Length'] !== '0') {
+            messageObject.body = body;
+        }
+        return messageObject;
+    };
+    instance.write = (messageObject) => {
+        let messageString = writeStartLine(messageObject);
+        messageString += '\r\n';
+        if (messageObject.body) {
+            messageObject.headers['Content-Length'] = String(Buffer.byteLength(messageObject.body));
+        }
+        for (const header in messageObject.headers) {
+            messageString += `${header}: ${messageObject.headers[header]}\r\n`;
+        }
+        messageString += '\r\n';
+        const buffer = Buffer.from(messageString);
+        if (!messageObject.body) {
+            return buffer;
+        }
+        return Buffer.concat([buffer, messageObject.body], buffer.length + messageObject.body.length);
+    };
+    return instance;
+};
+const HttpRequest = () => HttpMessage(() => { }, // currently not parsing requests.
+(messageObject) => `${messageObject.method} ${messageObject.path} HTTP/1.1`);
+const HttpResponse = () => HttpMessage((line, messageObject) => {
+    messageObject.statusCode = parseInt(line.split(' ')[1], 10);
+}, () => '');
+// ...
+class HttpClient {
+    resolveQueue = [];
+    pendingResponse = null;
+    socket;
+    host;
+    // ....
+    parseResponse(data) {
+        const res = HttpResponse().parse(data);
+        if (res.headers['Content-Length'] && Number(res.headers['Content-Length']) > 0) {
+            const remaining = Number(res.headers['Content-Length']) - (res.body?.byteLength ?? 0);
+            if (remaining > 0) {
+                // not all data for this response's corresponding request was read. Create a pending response object
+                // to use for further reads.
+                this.pendingResponse = {
+                    res,
+                    remaining
+                };
+            }
+        }
+        if (!this.pendingResponse) {
+            const rr = this.resolveQueue.shift();
+            if (!rr)
+                return;
+            res.statusCode === 200
+                ? rr.resolve(res)
+                : rr.resolve(null);
+        }
+    }
+    // ...
+    connect(host, port = 80) {
+        this.host = host;
+        return new Promise(resolve => {
+            this.socket = node_net_1.default.connect({
+                host,
+                port
+            }, resolve);
+            this.socket.on('data', data => {
+                if (!this.pendingResponse) {
+                    // there is no response pending, parse the data.
+                    this.parseResponse(data);
+                }
+                else {
+                    // incoming data for the pending response.
+                    const existing = this.pendingResponse.res.body ?? Buffer.alloc(0);
+                    this.pendingResponse.res.body = Buffer.concat([existing, data], data.byteLength + existing.byteLength);
+                    this.pendingResponse.remaining -= data.byteLength;
+                    if (this.pendingResponse.remaining === 0) {
+                        // all remaining data for the pending response has been read; resolve the promise for the 
+                        // corresponding request.
+                        const rr = this.resolveQueue.shift();
+                        if (!rr) {
+                            this.pendingResponse = null;
+                            return;
+                        }
+                        this.pendingResponse.res.statusCode === 200
+                            ? rr.resolve(this.pendingResponse.res)
+                            : rr.reject(new Error(`HTTP status: ${this.pendingResponse.res.statusCode}`));
+                        this.pendingResponse = null;
+                    }
+                }
+            });
+        });
+    }
+    request(method, path, headers, body) {
+        headers = headers || {};
+        // headers['Host'] = `${this.host}:${this.socket.remotePort}`;
+        const data = HttpRequest().write({
+            method,
+            path,
+            headers,
+            body
+        });
+        // ...
+        return new Promise((resolve, reject) => {
+            this.resolveQueue.push({ resolve, reject });
+            this.socket?.write(data);
+        });
+    }
+    close() {
+        this.socket?.end();
+    }
+}
+// ...
+const createHttpClient = () => new HttpClient();
+exports.default = createHttpClient;

package/dist/esm/utils/ntp.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNtpTimestamp = toNtpTimestamp;
+exports.parseNtpTimestamp = parseNtpTimestamp;
+exports.ntpFromUnixMs = ntpFromUnixMs;
+const config_1 = __importDefault(require("./config"));
+const NS_PER_SEC = 1000000000n;
+const FRAC_PER_SEC = 0x100000000n; // 2^32
+class NTP {
+    /** Convert monotonic clock to NTP epoch (1900-01-01) seconds + fractional. */
+    timestamp() {
+        const nowNs = process.hrtime.bigint();
+        const sec = Number(nowNs / NS_PER_SEC) + config_1.default.ntp_epoch;
+        const frac = Number(((nowNs % NS_PER_SEC) * FRAC_PER_SEC) / NS_PER_SEC);
+        const ts = Buffer.alloc(8);
+        ts.writeUInt32BE(sec >>> 0, 0);
+        ts.writeUInt32BE(frac >>> 0, 4);
+        return ts;
+    }
+    /** Return the current NTP fractional component (for compatibility). */
+    getTime() {
+        const nowNs = process.hrtime.bigint();
+        return Number(((nowNs % NS_PER_SEC) * FRAC_PER_SEC) / NS_PER_SEC);
+    }
+}
+exports.default = new NTP();
+/** Pack various NTP timestamp representations into a uint64 bigint (sec<<32|frac). */
+function toNtpTimestamp(input) {
+    if (typeof input === 'bigint')
+        return input;
+    if (typeof input === 'number')
+        return BigInt(input);
+    const sec = BigInt(input.sec >>> 0);
+    const frac = BigInt(input.frac >>> 0);
+    return (sec << 32n) | frac;
+}
+/** Parse an NTP timestamp (uint64 or sec/frac) into components. */
+function parseNtpTimestamp(input) {
+    if (typeof input === 'bigint' || typeof input === 'number') {
+        const value = typeof input === 'bigint' ? input : BigInt(input);
+        const sec = Number(value >> 32n);
+        const frac = Number(value & 0xffffffffn);
+        return { sec, frac };
+    }
+    return { sec: input.sec, frac: input.frac };
+}
+/** Build an NTP timestamp from a Unix epoch (ms). */
+function ntpFromUnixMs(unixMs) {
+    const sec = Math.floor(unixMs / 1000) + config_1.default.ntp_epoch;
+    const ms = unixMs % 1000;
+    const frac = Math.floor((ms / 1000) * Number(FRAC_PER_SEC));
+    return (BigInt(sec >>> 0) << 32n) | BigInt(frac >>> 0);
+}

package/dist/esm/utils/numUtil.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.low32 = exports.low16 = exports.randomInt = exports.randomBase64 = exports.randomHex = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const randomHex = (n) => node_crypto_1.default.randomBytes(n).toString('hex');
+exports.randomHex = randomHex;
+const randomBase64 = (n) => node_crypto_1.default.randomBytes(n).toString('base64').replace('=', '');
+exports.randomBase64 = randomBase64;
+const randomInt = (n) => Math.floor(Math.random() * Math.pow(10, n));
+exports.randomInt = randomInt;
+const low16 = (i) => Math.abs(i) % 65536;
+exports.low16 = low16;
+const low32 = (i) => Math.abs(i) % 4294967296;
+exports.low32 = low32;

package/dist/esm/utils/packetPool.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Packet = void 0;
+/**
+ * Reusable packet structure holding PCM/ALAC data plus sequence.
+ * Reference-counted to reduce allocations in the streaming path.
+ */
+class Packet {
+    pool;
+    ref = 1;
+    seq = null;
+    pcm;
+    constructor(pool, packetSize) {
+        this.pool = pool;
+        this.pcm = Buffer.alloc(packetSize);
+    }
+    /** Increment ref count when sharing the packet. */
+    retain() {
+        this.ref += 1;
+    }
+    /** Decrement ref count and return to pool when free. */
+    release() {
+        this.ref -= 1;
+        if (this.ref === 0) {
+            this.seq = null;
+            this.pool.release(this);
+        }
+    }
+}
+exports.Packet = Packet;
+/** Simple pool of Packet instances to avoid GC pressure during streaming. */
+class PacketPool {
+    packetSize;
+    pool = [];
+    constructor(packetSize) {
+        this.packetSize = packetSize;
+    }
+    /** Borrow a packet from the pool or allocate a new one. */
+    getPacket() {
+        const packet = this.pool.shift();
+        if (!packet) {
+            return new Packet(this, this.packetSize);
+        }
+        packet.retain();
+        return packet;
+    }
+    /** Return a packet to the pool. */
+    release(packet) {
+        this.pool.push(packet);
+    }
+}
+exports.default = PacketPool;

package/dist/esm/utils/util.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buf2hex = exports.hexString2ArrayBuffer = void 0;
+const hexString2ArrayBuffer = (hexString) => new Uint8Array(hexString.match(/[\da-f]{2}/gi)?.map((h) => parseInt(h, 16)) ?? []);
+exports.hexString2ArrayBuffer = hexString2ArrayBuffer;
+const buf2hex = (buffer) => Array.prototype.map
+    .call(new Uint8Array(buffer), (x) => `00${x.toString(16)}`.slice(-2))
+    .join('');
+exports.buf2hex = buf2hex;

package/dist/homekit/credentials.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Holds and serializes HomeKit credential blobs used during AirPlay 2 auth.
+ */
+declare class Credentials {
+    uniqueIdentifier: string;
+    identifier: Buffer;
+    pairingId: string;
+    publicKey: Buffer;
+    encryptionKey: Buffer;
+    encryptCount: number;
+    decryptCount: number;
+    writeKey: Buffer;
+    readKey: Buffer;
+    constructor(uniqueIdentifier: string, identifier: Buffer, pairingId: string, publicKey: Buffer, encryptionKey: Buffer);
+    /**
+    * Parse a credentials string into a Credentials object.
+    * @param text  The credentials string.
+    * @returns A credentials object.
+    */
+    static parse(text: string): Credentials;
+    /**
+    * Returns a string representation of a Credentials object.
+    * @returns A string representation of a Credentials object.
+    */
+    toString(): string;
+    encrypt(message: Buffer): Buffer;
+    decrypt(message: Buffer): Buffer;
+    encryptAudio(message: Buffer, aad: Buffer | null, nonce: number): Buffer;
+    rotateKeys(): void;
+}
+export { Credentials };

package/dist/homekit/credentials.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Credentials = void 0;
+const encryption_1 = __importDefault(require("./encryption"));
+const struct = require('python-struct');
+/**
+ * Holds and serializes HomeKit credential blobs used during AirPlay 2 auth.
+ */
+class Credentials {
+    uniqueIdentifier;
+    identifier;
+    pairingId;
+    publicKey;
+    encryptionKey;
+    encryptCount;
+    decryptCount;
+    writeKey;
+    readKey;
+    constructor(uniqueIdentifier, identifier, pairingId, publicKey, encryptionKey) {
+        this.uniqueIdentifier = uniqueIdentifier;
+        this.identifier = identifier;
+        this.pairingId = pairingId;
+        this.publicKey = publicKey;
+        this.encryptionKey = encryptionKey;
+        this.encryptCount = 0;
+        this.decryptCount = 0;
+        this.writeKey = encryptionKey;
+        this.readKey = encryptionKey;
+    }
+    /**
+    * Parse a credentials string into a Credentials object.
+    * @param text  The credentials string.
+    * @returns A credentials object.
+    */
+    static parse(text) {
+        const parts = text.split(':');
+        return new Credentials(parts[0], Buffer.from(parts[1], 'hex'), Buffer.from(parts[2], 'hex').toString(), Buffer.from(parts[3], 'hex'), Buffer.from(parts[4], 'hex'));
+    }
+    /**
+    * Returns a string representation of a Credentials object.
+    * @returns A string representation of a Credentials object.
+    */
+    toString() {
+        return this.uniqueIdentifier
+            + ":"
+            + this.identifier.toString('hex')
+            + ":"
+            + Buffer.from(this.pairingId).toString('hex')
+            + ":"
+            + this.publicKey.toString('hex')
+            + ":"
+            + this.encryptionKey.toString('hex');
+    }
+    encrypt(message) {
+        let offset = 0;
+        const total = message.byteLength;
+        let result = Buffer.concat([]);
+        while (offset < total) {
+            const length = Math.min(total - offset, 1024);
+            const s1lengthBytes = struct.pack("H", length);
+            // let cipher = crypto.createCipheriv('chacha20-poly1305', this.writeKey, Buffer.concat([Buffer.from([0x00,0x00,0x00,0x00]),struct.pack("Q", this.decryptCount)]), { authTagLength: 16 });
+            // cipher.setAAD(s1length_bytes);
+            // let s1ct = cipher.update(message);
+            // cipher.final();
+            // let s1tag = encryption_1.default.computePoly1305(s1ct,s1length_bytes,Buffer.concat([Buffer.from([0x00,0x00,0x00,0x00]),struct.pack("Q", this.decryptCount)]),this.writeKey)
+            const [s1ct, s1tag] = encryption_1.default.encryptAndSeal(message.slice(offset, offset + length), s1lengthBytes, Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), struct.pack("Q", this.encryptCount)]), this.writeKey);
+            const ciphertext = Buffer.concat([s1lengthBytes, s1ct, s1tag]);
+            offset += length;
+            this.encryptCount += 1;
+            result = Buffer.concat([result, ciphertext]);
+        }
+        return result;
+    }
+    decrypt(message) {
+        let offset = 0;
+        let result = Buffer.concat([]);
+        while (offset < message.byteLength) {
+            const lengthBytes = message.slice(offset, offset + 2);
+            const length = struct.unpack("H", lengthBytes);
+            const messagea = message.slice(offset + 2, offset + 2 + length[0] + 16);
+            const cipherText = messagea.slice(0, -16);
+            const hmac = messagea.slice(-16);
+            const decrypted = encryption_1.default.verifyAndDecrypt(cipherText, hmac, lengthBytes, Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), struct.pack("Q", this.decryptCount)]), this.readKey);
+            this.decryptCount += 1;
+            offset = offset + length[0] + 16 + 2;
+            result = Buffer.concat([result, decrypted ?? Buffer.alloc(0)]);
+        }
+        return result;
+    }
+    encryptAudio(message, aad, nonce) {
+        return Buffer.concat([
+            Buffer.concat(encryption_1.default.encryptAndSeal(message, aad, struct.pack("Q", nonce), this.writeKey)),
+            Buffer.from(struct.pack("Q", nonce)),
+        ]);
+    }
+    rotateKeys() {
+        const info = Buffer.from('AirPlay:Audio', 'utf-8'); // reference-style info
+        const salt = Buffer.alloc(16, 0); // deterministic salt like reference
+        const newKey = encryption_1.default.HKDF('sha256', salt, this.encryptionKey, info, 32);
+        this.writeKey = newKey;
+        this.readKey = newKey;
+        this.encryptCount = 0;
+        this.decryptCount = 0;
+    }
+}
+exports.Credentials = Credentials;

package/dist/homekit/encryption.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AirPlay 2/HomeKit encryption helpers (ChaCha20-Poly1305 + HKDF) ported from node_airtunes2.
+ */
+declare function verifyAndDecrypt(cipherText: Buffer, mac: Buffer, AAD: Buffer | null, nonce: Buffer, key: Buffer): Buffer | null;
+declare function encryptAndSeal(plainText: Buffer, AAD: Buffer | null, nonce: Buffer, key: Buffer): [Buffer, Buffer];
+declare function HKDF(hashAlg: string, salt: Buffer, ikm: Buffer, info: Buffer | string, size: number): Buffer;
+declare const _default: {
+    encryptAndSeal: typeof encryptAndSeal;
+    verifyAndDecrypt: typeof verifyAndDecrypt;
+    HKDF: typeof HKDF;
+};
+export default _default;

package/dist/homekit/encryption.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * AirPlay 2/HomeKit encryption helpers (ChaCha20-Poly1305 + HKDF) ported from node_airtunes2.
+ */
+// i'd really prefer for this to be a direct call to
+// Sodium.crypto_aead_chacha20poly1305_decrypt()
+// but unfortunately the way it constructs the message to
+// calculate the HMAC is not compatible with homekit
+// (long story short, it uses [ AAD, AAD.length, CipherText, CipherText.length ]
+// whereas homekit expects [ AAD, CipherText, AAD.length, CipherText.length ]
+function verifyAndDecrypt(cipherText, mac, AAD, nonce, key) {
+    try {
+        let nonceBuf = nonce;
+        if (nonceBuf.byteLength === 8) {
+            nonceBuf = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), nonceBuf]);
+        }
+        const decipher = crypto_1.default.createDecipheriv('chacha20-poly1305', key, nonceBuf, { authTagLength: 16 });
+        if (AAD != null) {
+            decipher.setAAD(AAD); // must be called before data
+        }
+        decipher.setAuthTag(mac);
+        const decrypted = Buffer.concat([decipher.update(cipherText), decipher.final()]);
+        return decrypted;
+    }
+    catch (error) {
+        return null;
+    }
+}
+function encryptAndSeal(plainText, AAD, nonce, key) {
+    let nonceBuf = nonce;
+    if (nonceBuf.byteLength === 8) {
+        nonceBuf = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x00]), nonceBuf]);
+    }
+    const cipher = crypto_1.default.createCipheriv('chacha20-poly1305', key, nonceBuf, { authTagLength: 16 });
+    if (AAD != null) {
+        cipher.setAAD(AAD); // must be called before data
+    }
+    const cipherText = Buffer.concat([cipher.update(plainText), cipher.final()]);
+    const hmac = cipher.getAuthTag();
+    return [cipherText, hmac];
+}
+// function getPadding(buffer, blockSize) {
+//     return buffer.length % blockSize === 0
+//         ? Buffer.alloc(0)
+//         : Buffer.alloc(blockSize - (buffer.length % blockSize));
+// }
+function HKDF(hashAlg, salt, ikm, info, size) {
+    // create the hash alg to see if it exists and get its length
+    const hash = crypto_1.default.createHash(hashAlg);
+    const hashLength = hash.digest().length;
+    // now we compute the PRK
+    const hmac = crypto_1.default.createHmac(hashAlg, salt);
+    hmac.update(ikm);
+    const prk = hmac.digest();
+    let prev = Buffer.alloc(0);
+    const buffers = [];
+    const numBlocks = Math.ceil(size / hashLength);
+    const infoBuf = Buffer.from(info);
+    for (let i = 0; i < numBlocks; i++) {
+        const roundHmac = crypto_1.default.createHmac(hashAlg, prk);
+        const input = Buffer.concat([
+            prev,
+            infoBuf,
+            Buffer.from(String.fromCharCode(i + 1)),
+        ]);
+        roundHmac.update(input);
+        prev = roundHmac.digest();
+        buffers.push(prev);
+    }
+    const output = Buffer.concat(buffers, size);
+    return output.slice(0, size);
+}
+exports.default = {
+    encryptAndSeal,
+    verifyAndDecrypt,
+    HKDF,
+};

package/dist/homekit/number.d.ts

@@ -0,0 +1,7 @@
+declare function UInt53toBufferLE(value: number): Buffer;
+declare function UInt16toBufferBE(value: number): Buffer;
+declare const _default: {
+    UInt53toBufferLE: typeof UInt53toBufferLE;
+    UInt16toBufferBE: typeof UInt16toBufferBE;
+};
+export default _default;

package/dist/homekit/number.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+/*
+ * Originally based on code from github:KhaosT/HAP-NodeJS@0c8fd88 used
+ * used per the terms of the Apache Software License v2.
+ *
+ * Original code copyright Khaos Tian <khaos.tian@gmail.com>
+ *
+ * Modifications copyright Zach Bean <zb@forty2.com>
+ *  * Reformatted for ES6-style module
+ *  * renamed *UInt64* to *UInt53* to be more clear about range
+ *  * renamed uintHighLow to be more clear about what it does
+ *  * Refactored to return a buffer rather write into a passed-in buffer
+ */
+function splitUInt53(value) {
+    const MAX_UINT32 = 0x00000000ffffffff;
+    const MAX_INT53 = 0x001fffffffffffff;
+    (0, assert_1.default)(value > -1 && value <= MAX_INT53, 'number out of range');
+    (0, assert_1.default)(Math.floor(value) === value, 'number must be an integer');
+    let high = 0;
+    const signbit = value & 0xffffffff;
+    const low = signbit < 0 ? (value & 0x7fffffff) + 0x80000000 : signbit;
+    if (value > MAX_UINT32) {
+        high = (value - low) / (MAX_UINT32 + 1);
+    }
+    return [high, low];
+}
+function UInt53toBufferLE(value) {
+    const [high, low] = splitUInt53(value);
+    const buf = Buffer.alloc(8);
+    buf.writeUInt32LE(low, 0);
+    buf.writeUInt32LE(high, 4);
+    return buf;
+}
+function UInt16toBufferBE(value) {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16BE(value, 0);
+    return buf;
+}
+exports.default = {
+    UInt53toBufferLE,
+    UInt16toBufferBE,
+};

package/dist/homekit/tlv.d.ts

@@ -0,0 +1,25 @@
+type TLVValue = Buffer | string | number;
+type TLVMap = Record<number, Buffer>;
+type TLVArgs = Array<number | TLVValue>;
+declare function encode(type: number, data: TLVValue, ...args: TLVArgs): Buffer;
+declare function decode(data: Buffer): TLVMap;
+declare const _default: {
+    Tag: {
+        readonly PairingMethod: 0;
+        readonly Username: 1;
+        readonly Salt: 2;
+        readonly PublicKey: 3;
+        readonly Proof: 4;
+        readonly EncryptedData: 5;
+        readonly Sequence: 6;
+        readonly ErrorCode: 7;
+        readonly BackOff: 8;
+        readonly Signature: 10;
+        readonly MFiCertificate: 9;
+        readonly MFiSignature: 10;
+        readonly Flags: 19;
+    };
+    encode: typeof encode;
+    decode: typeof decode;
+};
+export default _default;