lunibee 0.3.3 → 0.4.0

package/dist/voice/crypto.d.ts

@@ -0,0 +1,50 @@
+/** Transport encryption modes this package implements. */
+export type VoiceEncryptionMode = "aead_aes256_gcm_rtpsize" | "aead_xchacha20_poly1305_rtpsize";
+/** Modes in order of preference: AES-GCM when the runtime has it, XChaCha20-Poly1305 always. */
+export declare const SUPPORTED_ENCRYPTION_MODES: readonly VoiceEncryptionMode[];
+/** Picks the first mode in our preference order that the voice server offers. @throws {VoiceError} If none is offered. */
+export declare function chooseEncryptionMode(offered: readonly string[]): VoiceEncryptionMode;
+/** A parsed RTP packet header. */
+export interface RtpHeader {
+    version: number;
+    padding: boolean;
+    extension: boolean;
+    payloadType: number;
+    sequence: number;
+    timestamp: number;
+    ssrc: number;
+    /** Bytes authenticated but not encrypted: the fixed header, CSRCs and the extension header. */
+    headerSize: number;
+    /** 32-bit words of extension data, encrypted with the payload. */
+    extensionWords: number;
+}
+/** Writes the 12-byte RTP header Discord expects for an outgoing Opus packet. */
+export declare function rtpHeader(sequence: number, timestamp: number, ssrc: number): Uint8Array;
+/** Parses an RTP header, or returns `undefined` for anything that is not a complete RTP v2 header. */
+export declare function parseRtpHeader(packet: Uint8Array): RtpHeader | undefined;
+/**
+ * Seals and opens RTP packets for one voice session ("rtpsize" AEAD modes):
+ * the RTP header (and extension header) is authenticated, the rest is
+ * encrypted, and a 32-bit nonce counter is appended to the packet. The full
+ * nonce is that counter followed by zeros (12 bytes for AES-GCM, 24 for
+ * XChaCha20-Poly1305).
+ */
+export declare class PacketCipher {
+    #private;
+    readonly mode: VoiceEncryptionMode;
+    /** @param counter First nonce counter (default 0). */
+    constructor(mode: VoiceEncryptionMode, key: Uint8Array, counter?: number);
+    /** The nonce counter of the next sealed packet (wraps at 2^32). */
+    get counter(): number;
+    /** Encrypts `payload` under `header`. @returns The datagram: header, ciphertext, tag, nonce suffix. */
+    seal(header: Uint8Array, payload: Uint8Array): Uint8Array;
+    /**
+     * Decrypts a received datagram. Removes the encrypted extension data and
+     * RTP padding. @returns The header and the plaintext payload, or
+     * `undefined` when the packet is malformed or fails authentication.
+     */
+    open(packet: Uint8Array): {
+        header: RtpHeader;
+        payload: Uint8Array;
+    } | undefined;
+}

package/dist/voice/dave.d.ts

@@ -0,0 +1,85 @@
+/** The parts of `@snazzah/davey`'s session this package uses. */
+interface DaveyNativeSession {
+    readonly ready: boolean;
+    readonly voicePrivacyCode: string;
+    reinit(protocolVersion: number, userId: string, channelId: string): void;
+    reset(): void;
+    setExternalSender(data: Buffer): void;
+    getSerializedKeyPackage(): Buffer;
+    processProposals(operationType: number, proposals: Buffer, recognizedUserIds?: string[]): {
+        commit?: Buffer;
+        welcome?: Buffer;
+    };
+    processWelcome(welcome: Buffer): void;
+    processCommit(commit: Buffer): void;
+    encryptOpus(packet: Buffer): Buffer;
+    decrypt(userId: string, mediaType: number, packet: Buffer): Buffer;
+    canPassthrough(userId: string): boolean;
+    setPassthroughMode(passthrough: boolean, expirySeconds?: number): void;
+}
+/** The parts of `@snazzah/davey` this package uses. */
+export interface DaveyModule {
+    DAVE_PROTOCOL_VERSION: number;
+    DAVESession: new (protocolVersion: number, userId: string, channelId: string) => DaveyNativeSession;
+}
+/**
+ * Loads `@snazzah/davey` (the DAVE protocol: MLS group keys and frame
+ * encryption), an optional peer dependency. @returns The module, or `null`
+ * when it is not installed.
+ */
+export declare function loadDave(): Promise<DaveyModule | null>;
+/** Highest DAVE protocol version available here: 0 when `@snazzah/davey` is not installed. */
+export declare function maxDaveProtocolVersion(): Promise<number>;
+/** What a {@link DaveSession} asks its connection to send. */
+export interface DaveSessionHooks {
+    /** Send op 26 with this key package. */
+    keyPackage(payload: Uint8Array): void;
+    /** Send op 31: this transition could not be applied. */
+    invalidTransition(transitionId: number): void;
+    debug?(message: string): void;
+}
+/**
+ * One end-to-end encrypted (DAVE) media session: the MLS group of a voice
+ * channel, its protocol transitions, and Opus frame encryption. Follows the
+ * DAVE protocol's client flow (key package → proposals → commit/welcome →
+ * transition ready → execute).
+ */
+export declare class DaveSession {
+    #private;
+    protocolVersion: number;
+    constructor(module: DaveyModule, protocolVersion: number, userId: string, channelId: string, hooks: DaveSessionHooks);
+    /** Whether frames are currently end-to-end encrypted. */
+    get active(): boolean;
+    /** The voice privacy code users can compare, or `null` without DAVE. */
+    get voicePrivacyCode(): string | null;
+    /** (Re)creates the MLS state and announces a fresh key package. */
+    reinit(): void;
+    /** Op 25. */
+    setExternalSender(payload: Uint8Array): void;
+    /** Op 21. @returns Whether to answer with op 23 (transition ready). */
+    prepareTransition(transitionId: number, protocolVersion: number): boolean;
+    /** Op 22. @returns Whether a pending transition was executed. */
+    executeTransition(transitionId: number): boolean;
+    /** Op 24. */
+    prepareEpoch(epoch: number, protocolVersion: number): void;
+    /** Op 27. @returns The op 28 payload (commit, then welcome) to send, if any. */
+    processProposals(payload: Uint8Array, connectedUserIds: Iterable<string>): Uint8Array | undefined;
+    /** Op 29 (commit) or op 30 (welcome). @returns The transition and whether it applied; a failure re-initializes. */
+    process(kind: "commit" | "welcome", payload: Uint8Array): {
+        transitionId: number;
+        ok: boolean;
+    };
+    /**
+     * End-to-end encrypts an outgoing Opus frame. Silence frames, frames
+     * without DAVE (protocol version 0) and frames during an upgrade from
+     * transport-only stay as they are. @returns The frame to send, or `null`
+     * to drop it: DAVE is required but the MLS group is not ready (joining, or
+     * recovering from an invalid commit), so it must not leave unencrypted.
+     */
+    encrypt(frame: Uint8Array): Uint8Array | null;
+    /** Decrypts a frame from `userId`. @returns The Opus frame, or `null` to drop it. */
+    decrypt(frame: Uint8Array, userId: string): Uint8Array | null;
+    /** Drops the MLS state. */
+    destroy(): void;
+}
+export {};

package/dist/voice/effects.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A PCM effect: changes one 20 ms frame of 48 kHz stereo interleaved samples
+ * in place. Effects keep state between frames, so use one instance per
+ * resource.
+ */
+export interface AudioEffect {
+    process(samples: Int16Array): void;
+}
+/**
+ * Shifts the pitch by `semitones` (-24 to 24) without changing the speed:
+ * +12 is an octave up (a "chipmunk" voice), -7 a deeper one. A granular
+ * delay-line shifter, so it adds about 40 ms of latency.
+ */
+export declare function pitchShift(semitones: number): AudioEffect;
+/** A robot voice: ring modulation with a `frequency` Hz carrier (1 to 2,000, default 50). */
+export declare function robot(frequency?: number): AudioEffect;
+/** Options for {@link echo}. */
+export interface EchoOptions {
+    /** Delay in ms (1 to 2,000). Default 250. */
+    delay?: number;
+    /** How much of each echo is fed back (0 to 0.95). Default 0.4. */
+    feedback?: number;
+    /** Echo level in the output (0 to 1). Default 0.5. */
+    mix?: number;
+}
+/** An echo. Its buffer is fixed by `delay` (at most 2 s, 750 KB). */
+export declare function echo(options?: EchoOptions): AudioEffect;
+/** Linear gain (0 to 16): 0.5 is half, 2 double (clipped). */
+export declare function gain(factor: number): AudioEffect;
+/** @internal Runs `effects` over one s16le PCM frame; returns a new full frame (3,840 bytes). */
+export declare function applyEffects(effects: readonly AudioEffect[], pcm: Uint8Array): Uint8Array;

package/dist/voice/emitter.d.ts

@@ -0,0 +1,14 @@
+/** A small typed event emitter: listener failures are isolated, nothing is async. */
+export declare class Emitter<E extends {
+    [K in keyof E]: unknown[];
+}> {
+    #private;
+    /** Adds a listener. @throws {TypeError} If it is not a function. */
+    on<K extends keyof E>(event: K, listener: (...args: E[K]) => unknown): this;
+    /** Removes a listener. */
+    off<K extends keyof E>(event: K, listener: (...args: E[K]) => unknown): this;
+    /** Calls the listeners of `event`; one that throws does not stop the others. */
+    protected emit<K extends keyof E>(event: K, ...args: E[K]): void;
+    /** Drops every listener. */
+    protected removeAllListeners(): void;
+}

package/dist/voice/gateway.d.ts

@@ -0,0 +1,59 @@
+/** A JSON voice gateway frame. */
+export interface VoicePacket {
+    op: number;
+    d?: unknown;
+    seq?: number;
+}
+/** A binary voice gateway frame (DAVE): sequence, opcode and payload. */
+export interface VoiceBinaryPacket {
+    seq: number;
+    op: number;
+    payload: Uint8Array;
+}
+/** The parts of a WebSocket {@link VoiceGateway} uses; the global `WebSocket` provides them. */
+export interface VoiceSocketLike {
+    binaryType: string;
+    readonly readyState: number;
+    send(data: string | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: string, listener: (event: never) => void): void;
+}
+/** Opens a WebSocket. Replace it in tests. */
+export type VoiceSocketFactory = (url: string) => VoiceSocketLike;
+/** The default factory: the runtime's global `WebSocket`. */
+export declare const globalVoiceSocket: VoiceSocketFactory;
+/** What a {@link VoiceGateway} reports to its owner. */
+export interface VoiceGatewayHandlers {
+    open(): void;
+    packet(packet: VoicePacket): void;
+    binary(packet: VoiceBinaryPacket): void;
+    close(code: number, reason: string): void;
+    error(error: Error): void;
+}
+/** Client close code for missed heartbeat ACKs: below 4000, so the session resumes. */
+export declare const HEARTBEAT_TIMEOUT_CLOSE = 3001;
+/** Builds the voice gateway URL for an endpoint from VOICE_SERVER_UPDATE. */
+export declare function voiceGatewayURL(endpoint: string): string;
+/**
+ * One voice gateway WebSocket (v8). Parses JSON and binary frames, tracks the
+ * last sequence for `seq_ack`, and heartbeats with `@lunibee/ws`'s
+ * {@link GatewayHeartbeat} (an unanswered heartbeat closes with
+ * {@link HEARTBEAT_TIMEOUT_CLOSE}, which the owner resumes).
+ */
+export declare class VoiceGateway {
+    #private;
+    /** The last sequence number received, `-1` before any. Sent back as `seq_ack`. */
+    sequence: number;
+    constructor(url: string, handlers: VoiceGatewayHandlers, options?: {
+        factory?: VoiceSocketFactory;
+        sequence?: number;
+    });
+    /** Round trip of the last heartbeat, or -1. */
+    get ping(): number;
+    /** Sends a JSON frame. @returns Whether the socket was open. */
+    sendJSON(packet: VoicePacket): boolean;
+    /** Sends a binary frame: the opcode byte followed by the payload. */
+    sendBinary(op: number, payload: Uint8Array): boolean;
+    /** Closes the socket and stops heartbeating. A `1000` close is not reported back. */
+    close(code?: number, reason?: string): void;
+}

package/dist/voice/index.d.ts

@@ -1,230 +1,27 @@
-/** Voice session lifecycle states. */
-export declare enum VoiceConnectionState {
-    Disconnected = "disconnected",
-    Connecting = "connecting",
-    Connected = "connected",
-    Destroyed = "destroyed"
-}
-/** Voice protocol transport errors. */
-export declare class VoiceError extends Error {
-    /** Creates a voice error. @param message Error message. @param options Optional native error options. */
-    constructor(message: string, options?: ErrorOptions);
-}
-/** Options used to establish a voice session. */
-export interface VoiceConnectionOptions {
-    /** Guild containing the voice channel. */
-    guildId: string;
-    /** Voice channel to join. */
-    channelId?: string;
-    /** Whether the self user should be muted. */
-    selfMute?: boolean;
-    /** Whether the self user should be deafened. */
-    selfDeaf?: boolean;
-}
-/** UDP transport supplied by the runtime-specific voice implementation. */
-export interface VoiceUdpTransport {
-    /** Sends an RTP/RTCP packet. @param packet Packet bytes. @param host Destination host. @param port Destination port. @returns Optional completion promise. */
-    send(packet: Uint8Array, host: string, port: number): Promise<void> | void;
-    /** Closes the UDP socket. @returns Nothing. */
-    close(): void;
-    /** Optional listener for incoming UDP packets. */
-    onMessage?(listener: (packet: Uint8Array) => void): void;
-}
-/** A JSON frame for the voice gateway, e.g. `{ op: 5, d: { speaking, delay, ssrc } }`. */
-export interface VoiceGatewayPayload {
-    op: number;
-    d: Record<string, string | number | boolean | null>;
-}
-/** Voice Gateway transport abstraction. */
-export interface VoiceGatewayTransport {
-    /** Opens the voice gateway. @param endpoint Voice gateway endpoint. @param sessionId Voice session identifier. @returns Promise fulfilled when connected. */
-    connect(endpoint: string, sessionId: string): Promise<void>;
-    /** Sends a voice gateway payload. @param payload Gateway payload. @returns Nothing. */
-    send(payload: VoiceGatewayPayload): void;
-    /** Closes the voice gateway. @param code Optional close code. @param reason Optional close reason. @returns Nothing. */
-    close(code?: number, reason?: string): void;
-}
-/** Speaking flags used by the voice gateway. */
-export declare const SpeakingFlags: {
-    readonly Microphone: 1;
-    readonly Soundshare: 2;
-    readonly Priority: 4;
-};
-/** Voice session event payloads. */
-export interface VoiceEvents {
-    /** State transition event. */
-    stateChange: [VoiceConnectionState, VoiceConnectionState];
-    /** Speaking flag event. */
-    speaking: [number, number];
-    /** Voice transport error event. */
-    error: [VoiceError];
-}
-/** Tracks a Discord voice session and exposes transport-independent lifecycle controls. */
-export declare class VoiceConnection {
-    #private;
-    /** Current voice connection state. */
-    state: VoiceConnectionState;
-    /** Guild associated with this voice session. */
-    readonly guildId: string;
-    /** Voice channel associated with this session. */
-    channelId?: string;
-    /** Whether the client is self-muted. */
-    selfMute: boolean;
-    /** Whether the client is self-deafened. */
-    selfDeaf: boolean;
-    /** Active voice gateway transport, when attached. */
-    gateway?: VoiceGatewayTransport;
-    /** Active UDP transport, when attached. */
-    udp?: VoiceUdpTransport;
-    /** Receives incoming audio. */
-    readonly receiver: VoiceReceiver;
-    /** Creates a voice connection state manager. @param options Guild ID or connection options. @throws {TypeError} If the guild ID is empty. */
-    constructor(options: string | VoiceConnectionOptions);
-    /** Registers a voice lifecycle listener. @param event Event name. @param listener Listener callback. @returns This connection. @throws {TypeError} If listener is not callable. */
-    on<K extends keyof VoiceEvents>(event: K, listener: (...args: VoiceEvents[K]) => unknown): this;
-    /** Removes a voice lifecycle listener. @param event Event name. @param listener Listener callback. @returns This connection. */
-    off<K extends keyof VoiceEvents>(event: K, listener: (...args: VoiceEvents[K]) => unknown): this;
-    /** Attaches protocol transports, replacing and cleaning up the old pair when present. @param gateway Voice gateway transport. @param udp UDP transport. @returns This connection. @throws {VoiceError} If the connection is destroyed. @throws {TypeError} If a transport is missing. */
-    attachTransports(gateway: VoiceGatewayTransport, udp: VoiceUdpTransport): this;
-    /** Begins the connection lifecycle. @returns Nothing. @throws {VoiceError} If the connection is destroyed. */
-    connect(): void;
-    /** Disconnects the current voice session. @returns Nothing. */
-    disconnect(): void;
-    /** Permanently destroys this voice connection. @returns Nothing. */
-    destroy(): void;
-    /** Updates the voice channel and connection state. @param channelId Voice channel identifier. @returns Nothing. @throws {VoiceError} If the connection is destroyed. @throws {TypeError} If channelId is empty. */
-    setChannel(channelId: string): void;
-    /** Updates self mute/deaf state. @param options Suppression flags. @returns Nothing. @throws {VoiceError} If the connection is destroyed. */
-    setSuppression(options: {
-        selfMute?: boolean;
-        selfDeaf?: boolean;
-    }): void;
-    /** Publishes a speaking state through the attached voice gateway. @param flags Speaking flags. @returns Nothing. @throws {VoiceError} If the connection is destroyed or has no gateway transport. */
-    /**
-     * Sends a speaking update (voice op 5). Pass the `ssrc` your voice gateway
-     * assigned in READY; Discord uses it to match the audio to this user.
-     */
-    setSpeaking(flags?: number, ssrc?: number): void;
-    /** Ensures the connection is still usable. @returns Nothing. @throws {VoiceError} If destroyed. */
-    private assertUsable;
-}
-/** Audio player lifecycle states. */
-export type AudioPlayerState = "idle" | "playing" | "paused" | "stopped";
-/** An audio stream — wraps a `ReadableStream<Uint8Array>` with optional metadata. */
-export declare class AudioStream {
-    /** Underlying binary stream. */
-    readonly stream: ReadableStream<Uint8Array>;
-    /** Optional human-readable title for the stream. */
-    readonly title?: string;
-    /** Optional duration hint in seconds. */
-    readonly duration?: number;
-    /** Creates an audio stream.
-     * @param stream Binary audio data stream.
-     * @param metadata Optional metadata: title and duration in seconds.
-     */
-    constructor(stream: ReadableStream<Uint8Array>, metadata?: {
-        title?: string;
-        duration?: number;
-    });
-}
-type AudioPlayerListener<K extends keyof AudioPlayerEvents> = (...args: AudioPlayerEvents[K]) => unknown;
-interface AudioPlayerEvents {
-    stateChange: [from: AudioPlayerState, to: AudioPlayerState];
-    error: [error: Error];
-    finish: [];
-}
+import { VoiceConnection, type VoiceConnectionStatus } from "./connection.js";
+import { AudioPlayer, type AudioPlayerStatus } from "./player.js";
+export { VOICE_GATEWAY_VERSION, VoiceOpcodes, VoiceCloseCodes, canResumeVoice, RTP_OPUS_PAYLOAD_TYPE, FRAME_DURATION_MS, FRAME_SAMPLES, PCM_FRAME_BYTES, SILENCE_FRAME, SpeakingFlags, VoiceError, } from "./protocol.js";
+export { PacketCipher, SUPPORTED_ENCRYPTION_MODES, chooseEncryptionMode, parseRtpHeader, rtpHeader, type RtpHeader, type VoiceEncryptionMode, } from "./crypto.js";
+export { VoiceGateway, voiceGatewayURL, HEARTBEAT_TIMEOUT_CLOSE, type VoiceBinaryPacket, type VoiceGatewayHandlers, type VoicePacket, type VoiceSocketFactory, type VoiceSocketLike, } from "./gateway.js";
+export { VoiceUdp, bunUdpSocket, discoveryRequest, parseDiscoveryResponse, type UdpSocketFactory, type UdpSocketLike, } from "./udp.js";
+export { DaveSession, loadDave, maxDaveProtocolVersion, type DaveSessionHooks, } from "./dave.js";
+export { VoiceNetworking, type NetworkingState, type VoiceNetworkingHandlers, type VoiceNetworkingOptions, type VoiceServerInfo, } from "./networking.js";
+export { createOpusCodec, type OpusCodec } from "./opus.js";
+export { Opus, OpusApplication, hasLibopus, libopusVersion, loadLibopus, } from "./libopus.js";
+export { demuxOggOpus, OggOpusWriter } from "./ogg.js";
+export { pitchShift, robot, echo, gain, type AudioEffect, type EchoOptions, } from "./effects.js";
+export { AudioResource, VolumeControl, createAudioResource, type AudioInput, type AudioResourceOptions, type StreamType, } from "./resource.js";
+export { AudioPlayer, AudioPlayerStatus, createAudioPlayer, type AudioPlayerEvents, type AudioPlayerOptions, type AudioSink, } from "./player.js";
+export { VoiceReceiver, type ReceiveEnd, type ReceiveOptions, type RecordOptions, } from "./receiver.js";
+export { VoiceConnection, VoiceConnectionStatus, VoiceManager, getVoiceConnection, joinVoiceChannel, type DisconnectReason, type JoinVoiceChannelOptions, type PlayerSubscription, type VoiceAdapter, type VoiceAdapterCreator, type VoiceAdapterMethods, type VoiceConnectionEvents, type VoiceJoinOptions, type VoiceManagerClient, type VoiceServerData, type VoiceStateData, type VoiceStatePayload, } from "./connection.js";
 /**
- * Lightweight audio player with a simple state machine.
- *
- * States:
- * - `idle` — no stream loaded.
- * - `playing` — actively feeding audio data.
- * - `paused` — temporarily suspended; can be resumed.
- * - `stopped` — stream was stopped and discarded; load a new stream to play again.
- *
- * Events: `stateChange(from, to)`, `error(err)`, `finish()`.
+ * Resolves once `target` reaches `status`, or rejects after `timeoutMs`.
+ * @throws {VoiceError} If the status is not reached in time.
  */
-export declare class AudioPlayer {
-    #private;
-    /** Current player state. */
-    get state(): AudioPlayerState;
-    /** The audio stream currently loaded, if any. */
-    get current(): AudioStream | undefined;
-    /**
-     * Begins playing an audio stream.
-     * If a stream is already playing, it is stopped first; the previous
-     * stream's reader cancellation is awaited before the new stream starts so
-     * the old and new pump loops cannot run concurrently.
-     * @param audioStream Stream to play.
-     */
-    play(audioStream: AudioStream): Promise<void>;
-    /** Pauses a currently-playing stream. No-op if not playing. */
-    pause(): void;
-    /** Resumes a paused stream. No-op if not paused. */
-    resume(): void;
-    /**
-     * Stops and discards the current stream. The returned promise resolves once
-     * the underlying reader's cancellation has settled, so a subsequent `play`
-     * never overlaps with the previous pump loop.
-     */
-    stop(): Promise<void>;
-    /** Registers an event listener. @returns `this` for chaining. */
-    on<K extends keyof AudioPlayerEvents>(event: K, listener: AudioPlayerListener<K>): this;
-    /** Removes an event listener. @returns `this` for chaining. */
-    off<K extends keyof AudioPlayerEvents>(event: K, listener: AudioPlayerListener<K>): this;
-    /**
-     * Handles a decoded audio chunk. The base implementation is a no-op;
-     * subclasses override this to pipe audio to a UDP socket or other sink.
-     * @param chunk A chunk of audio bytes read from the current stream.
-     */
-    protected onChunk(chunk: Uint8Array): void;
-}
-/** Tracks incoming audio and maps SSRCs to readable streams per user. */
-export declare class VoiceReceiver {
-    #private;
-    /** The connection this receiver is attached to. */
-    readonly connection: VoiceConnection;
-    /** Creates a VoiceReceiver. @param connection Voice connection. */
-    constructor(connection: VoiceConnection);
-    /** Maps an SSRC to a User ID (usually from gateway speaking events). */
-    mapSsrc(ssrc: number, userId: string): void;
-    /** Subscribes to incoming audio from a specific user. @param userId User identifier. @returns A binary readable stream of the audio. */
-    subscribe(userId: string): AudioStream;
-    /** Ends every subscriber stream and forgets SSRC mappings. Called when the
-     * connection disconnects or is destroyed, so readers do not wait forever. */
-    close(): void;
-    /** Processes an incoming UDP packet, extracting SSRC and routing the audio
-     * payload (RTP header stripped) to every subscriber for the mapped user. */
-    onPacket(packet: Uint8Array): void;
-}
-/** Discord.js-familiar alias for {@link VoiceConnectionState}. Member values are Lunibee's. */
-export { VoiceConnectionState as VoiceConnectionStatus };
-/**
- * Joins (or moves to) a voice channel, reusing the guild's tracked connection.
- * Mirrors `@discordjs/voice`'s `joinVoiceChannel`; transports are still attached
- * with {@link VoiceConnection.attachTransports}.
- * The connection stays tracked after `disconnect()` (a later join reuses it) and
- * leaves the registry only on `destroy()`.
- * @param options Guild, channel and self mute/deaf flags.
- * @returns The guild's voice connection.
- * @throws {TypeError} If the guild or channel ID is empty.
- */
-export declare function joinVoiceChannel(options: VoiceConnectionOptions & {
-    channelId: string;
-}): VoiceConnection;
-/** Returns the connection tracked by {@link joinVoiceChannel} for a guild, if any. */
-export declare function getVoiceConnection(guildId: string): VoiceConnection | undefined;
-/** Creates an {@link AudioPlayer}. Mirrors `@discordjs/voice`'s `createAudioPlayer`. */
-export declare function createAudioPlayer(): AudioPlayer;
-/** Creates an {@link AudioStream}. Mirrors `@discordjs/voice`'s `createAudioResource`. */
-export declare function createAudioResource(stream: ReadableStream<Uint8Array>, metadata?: {
-    title?: string;
-    duration?: number;
-}): AudioStream;
-/**
- * Resolves once a connection or player reaches `status`, or rejects after `timeoutMs`.
- * Mirrors `@discordjs/voice`'s `entersState`.
- * @returns The same target, for chaining.
- * @throws {VoiceError} If the state is not reached in time.
- */
-export declare function entersState<T extends VoiceConnection | AudioPlayer>(target: T, status: T extends VoiceConnection ? VoiceConnectionState : AudioPlayerState, timeoutMs: number): Promise<T>;
+export declare function entersState<T extends VoiceConnection | AudioPlayer>(target: T, status: T extends VoiceConnection ? VoiceConnectionStatus : AudioPlayerStatus, timeoutMs: number): Promise<T>;
+/** Which optional voice dependencies this runtime can load. */
+export declare function generateDependencyReport(): Promise<{
+    dave: string | null;
+    opus: string | null;
+    ffmpeg: string | null;
+}>;