lox-airplay-sender 0.1.0

package/dist/esm/utils/ntp.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("./config"));
+class NTP {
+    timeRef = Date.now() - config_1.default.ntp_epoch * 1000;
+    timestamp() {
+        const time = Date.now() - this.timeRef;
+        const sec = Math.floor(time / 1000);
+        const msec = time - sec * 1000;
+        const ntp_msec = Math.floor(msec * 4294967.296);
+        const ts = Buffer.alloc(8);
+        ts.writeUInt32BE(sec, 0);
+        ts.writeUInt32BE(ntp_msec, 4);
+        return ts;
+    }
+    getTime() {
+        const time = Date.now() - this.timeRef;
+        const sec = Math.floor(time / 1000);
+        const msec = time - sec * 1000;
+        const ntp_msec = Math.floor(msec * 4294967.296);
+        return ntp_msec;
+    }
+}
+exports.default = new NTP();

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,30 @@
+/**
+ * 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;
+}
+export { Credentials };

package/dist/homekit/credentials.js

@@ -0,0 +1,100 @@
+"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)),
+        ]);
+    }
+}
+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;

package/dist/homekit/tlv.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Type Length Value encoding/decoding, used by HAP as a wire format.
+ * https://en.wikipedia.org/wiki/Type-length-value
+ */
+const Tag = {
+    PairingMethod: 0x00,
+    Username: 0x01,
+    Salt: 0x02,
+    // could be either the SRP client public key (384 bytes) or the ED25519 public key (32 bytes), depending on context
+    PublicKey: 0x03,
+    Proof: 0x04,
+    EncryptedData: 0x05,
+    Sequence: 0x06,
+    ErrorCode: 0x07,
+    BackOff: 0x08,
+    Signature: 0x0a,
+    MFiCertificate: 0x09,
+    MFiSignature: 0x0a,
+    Flags: 0x13,
+};
+function encodeOne(type, data) {
+    let bufferData;
+    if (typeof data === 'number') {
+        bufferData = Buffer.from([data]);
+    }
+    else if (typeof data === 'string') {
+        bufferData = Buffer.from(data);
+    }
+    else {
+        bufferData = data;
+    }
+    if (bufferData.length <= 255) {
+        return Buffer.concat([Buffer.from([type, bufferData.length]), bufferData]);
+    }
+    let leftLength = bufferData.length;
+    let tempBuffer = Buffer.alloc(0);
+    let currentStart = 0;
+    for (; leftLength > 0;) {
+        if (leftLength >= 255) {
+            tempBuffer = Buffer.concat([
+                tempBuffer,
+                Buffer.from([type, 0xff]),
+                bufferData.slice(currentStart, currentStart + 255),
+            ]);
+            leftLength -= 255;
+            currentStart += 255;
+        }
+        else {
+            tempBuffer = Buffer.concat([
+                tempBuffer,
+                Buffer.from([type, leftLength]),
+                bufferData.slice(currentStart, currentStart + leftLength),
+            ]);
+            leftLength = 0;
+        }
+    }
+    return tempBuffer;
+}
+function encode(type, data, ...args) {
+    const encodedTLVBuffer = encodeOne(type, data);
+    if (args.length === 0) {
+        return encodedTLVBuffer;
+    }
+    const nextType = args[0];
+    const nextData = args[1];
+    const remaining = args.slice(2);
+    const remainingTLVBuffer = encode(nextType, nextData, ...remaining);
+    return Buffer.concat([encodedTLVBuffer, remainingTLVBuffer]);
+}
+function decode(data) {
+    const objects = {};
+    let leftLength = data.length;
+    let currentIndex = 0;
+    for (; leftLength > 0;) {
+        const type = data[currentIndex];
+        const length = data[currentIndex + 1];
+        currentIndex += 2;
+        leftLength -= 2;
+        const newData = data.slice(currentIndex, currentIndex + length);
+        if (objects[type]) {
+            objects[type] = Buffer.concat([objects[type], newData]);
+        }
+        else {
+            objects[type] = newData;
+        }
+        currentIndex += length;
+        leftLength -= length;
+    }
+    return objects;
+}
+exports.default = {
+    Tag,
+    encode,
+    decode,
+};

package/dist/index.d.ts

@@ -0,0 +1,109 @@
+import { EventEmitter } from 'node:events';
+import { Readable } from 'node:stream';
+/**
+ * Configuration for a single AirPlay sender.
+ */
+export interface LoxAirplaySenderOptions {
+    host: string;
+    /** RAOP port (defaults to 5000). */
+    port?: number;
+    /** Display name shown on the receiver. */
+    name?: string;
+    /** AirPlay 1 password; null disables auth. */
+    password?: string | null;
+    /** Initial volume 0–100 (default 50). */
+    volume?: number;
+    /** Explicit RAOP mode; defaults based on airplay2 flag. */
+    mode?: number;
+    /** Additional TXT records to advertise. */
+    txt?: string[];
+    /** Force ALAC encoding even when input is ALAC. */
+    forceAlac?: boolean;
+    /** Enable ALAC encoding pipeline. */
+    alacEncoding?: boolean;
+    /** Input format; pcm triggers encoding, alac passes through. */
+    inputCodec?: 'pcm' | 'alac';
+    /** Enable AirPlay 2 authentication + flags. */
+    airplay2?: boolean;
+    /** Emit verbose transport logs. */
+    debug?: boolean;
+    /** Optional unix ms start time for synced playback. */
+    startTimeMs?: number;
+    /** Logger hook for internal messages. */
+    log?: (level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: unknown) => void;
+}
+/**
+ * Metadata sent to receivers for UI display.
+ */
+export interface AirplayMetadata {
+    title?: string;
+    artist?: string;
+    album?: string;
+    cover?: {
+        data: Buffer;
+        mime?: string;
+    };
+    coverUrl?: string;
+    elapsedMs?: number;
+    durationMs?: number;
+}
+export interface LoxAirplayEvent {
+    event: string;
+    message?: string;
+    detail?: any;
+}
+export declare class LoxAirplaySender extends EventEmitter {
+    private airtunes;
+    private deviceKey;
+    private started;
+    private source;
+    private log?;
+    private lastTrackKey;
+    private lastCoverKey;
+    private lastProgressKey;
+    private lastCoverUrl;
+    private coverFetch?;
+    private artworkTimer?;
+    private pendingArtwork?;
+    private lastTrackChangeAt;
+    /**
+     * Create + start a sender for a single AirPlay device.
+     * Returns true when the pipeline initializes; safe to call multiple times to restart.
+     */
+    start(options: LoxAirplaySenderOptions, onEvent?: (event: LoxAirplayEvent) => void): boolean;
+    /**
+     * Push raw PCM or ALAC frames into the stream.
+     */
+    sendPcm(chunk: Buffer): void;
+    /**
+     * Pipe a readable stream into the sender; auto-stops on end/error.
+     */
+    pipeStream(stream: Readable): void;
+    /** Adjust receiver volume (0–100). */
+    setVolume(volume: number): void;
+    /** Update track metadata immediately without artwork/progress. */
+    setTrackInfo(title: string, artist?: string, album?: string): void;
+    /** Send cover art immediately. */
+    setArtwork(art: Buffer, contentType?: string): void;
+    /** Send playback progress in seconds (elapsed, duration). */
+    setProgress(progress: number, duration: number): void;
+    /**
+     * Convenience to send track info, cover (buffer or URL), and progress.
+     * Deduplicates payloads and staggers artwork on track changes.
+     */
+    setMetadata(payload: AirplayMetadata): Promise<void>;
+    /** Provide a passcode when a receiver requests it. */
+    setPasscode(passcode: string): void;
+    /**
+     * Stop streaming and tear down state/sockets. Safe to call multiple times.
+     */
+    stop(): void;
+    private fetchCover;
+    private sendArtworkNow;
+    private queueArtwork;
+}
+/**
+ * Convenience helper to construct + start a sender in one call.
+ */
+export declare function start(options: LoxAirplaySenderOptions, onEvent?: (event: LoxAirplayEvent) => void): LoxAirplaySender;
+export default LoxAirplaySender;