Skip to main content

Types Reference

A comprehensive reference for Yukino's TypeScript types, enums, and interfaces. Use this as a guide for configuration, event handling, and advanced usage.


Constants​

Events​

Defines all event names emitted by Yukino for node, player, track, voice, and WebSocket events.

enum Events {
// Node events
NODE_READY = 'nodeReady',
NODE_ERROR = 'nodeError',
NODE_CLOSED = 'nodeClosed',
NODE_RECONNECT = 'nodeReconnect',
NODE_STATS = 'nodeStats',
NODE_EVENT = 'nodeEvent',
NODE_ADD = 'nodeAdd',

// Player events
PLAYER_CREATE = 'playerCreate',
PLAYER_DESTROY = 'playerDestroy',
PLAYER_UPDATE = 'playerUpdate',

// Track events
TRACK_START = 'trackStart',
TRACK_END = 'trackEnd',
TRACK_ERROR = 'trackError',
TRACK_STUCK = 'trackStuck',

// Voice events
VOICE_CONNECTED = 'voiceConnected',
VOICE_DISCONNECTED = 'voiceDisconnected',
VOICE_STATE_UPDATE = 'voiceStateUpdate',
VOICE_SERVER_UPDATE = 'voiceServerUpdate',

// WebSocket events
WS_CLOSED = 'wsClosed',
WS_ERROR = 'wsError',
WS_OPEN = 'wsOpen',
}

LoadTypes​

Represents the possible results of a track load/search operation.

enum LoadTypes {
TRACK_LOADED = 'track',
PLAYLIST_LOADED = 'playlist',
SEARCH_RESULT = 'search',
NO_MATCHES = 'empty',
LOAD_FAILED = 'error'
}

State​

Represents the connection state of a node.

enum State {
CONNECTING = 0,
CONNECTED = 1,
DISCONNECTING = 2,
DISCONNECTED = 3,
RECONNECTING = 4
}

PlayerStates​

Represents the playback state of a player.

enum PlayerStates {
PLAYING = 'playing',
PAUSED = 'paused',
IDLE = 'idle'
}

Configuration Interfaces​

ConnectorOptions​

Options for initializing a Yukino connector.

interface ConnectorOptions {
client: Client;
name?: string;
host?: string;
port?: number | string;
url?: string;
auth: string;
secure?: boolean;
version?: string;
sessionId?: string;
debug?: boolean;
restOptions?: RestOptions;
defaultSearchEngine?: string;
userAgent?: string;
reconnectInterval?: number;
reconnectTries?: number;
}

NodeOptions​

Options for configuring a Lavalink node connection.

interface NodeOptions {
name: string;
url: string;
auth: string;
secure?: boolean;
group?: string;
reconnectInterval?: number;
reconnectTries?: number;
/** Number of reconnection attempts (alias for reconnectTries) */
retryAmount?: number;
/** Delay between reconnection attempts in ms (alias for reconnectInterval) */
retryDelay?: number;
/** Nested reconnect options (docs compatibility) */
reconnectOptions?: {
retryAmount?: number;
retryDelay?: number;
};
resumeKey?: string | null;
resumeTimeout?: number;
version?: string;
debug?: boolean;
priority?: number;
region?: string;
}

PlayerOptions​

Options for creating or configuring a player instance.

interface PlayerOptions {
guildId: string;
textChannelId?: string;
voiceChannelId: string;
deaf?: boolean;
mute?: boolean;
selfDeaf?: boolean;
selfMute?: boolean;
volume?: number;
queueOptions?: QueueOptions;
node?: string;
nodeGroup?: string;
autoReconnect?: boolean;
options?: {
inactivityTimeout?: number;
volumeDecrementer?: number;
bufferingTimeout?: number;
[key: string]: any;
};
}

QueueOptions​

Options for customizing the player queue.

interface QueueOptions {
maxSize?: number;
defaultVolume?: number;
durationType?: "ms" | "s";
}

RestOptions​

Options for REST API communication with Lavalink.

interface RestOptions {
url: string;
auth: string;
secure?: boolean;
timeout?: number;
version?: string;
debug?: boolean;
headers?: Record<string, string>;
retries?: number;
}

YukinoOptions​

Top-level options for initializing the Yukino client.

interface YukinoOptions {
nodes: NodeOptions[];
defaultSearchEngine?: string;
defaultPlayerOptions?: PlayerOptions;
reconnectTries?: number;
reconnectInterval?: number;
restTimeout?: number;
structures?: {
Node?: typeof Node;
Player?: typeof Player;
};
send: (guildId: string, payload: any) => Promise<void>;
}

Filter Interfaces​

FilterOptions​

Options for applying audio filters to a player.

interface FilterOptions {
volume?: number;
equalizer?: EqualizerBand[];
karaoke?: KaraokeOptions;
timescale?: TimescaleOptions;
tremolo?: FrequencyDepthOptions;
vibrato?: FrequencyDepthOptions;
rotation?: RotationOptions;
distortion?: DistortionOptions;
channelMix?: ChannelMixOptions;
lowPass?: LowPassOptions;
}

EqualizerBand​

Represents a single band in the equalizer filter.

interface EqualizerBand {
band: number;
gain: number;
}

KaraokeOptions​

Options for the karaoke audio filter.

interface KaraokeOptions {
level?: number;
monoLevel?: number;
filterBand?: number;
filterWidth?: number;
}

TimescaleOptions​

Options for the timescale audio filter.

interface TimescaleOptions {
speed?: number;
pitch?: number;
rate?: number;
}

FrequencyDepthOptions​

Options for tremolo and vibrato filters.

interface FrequencyDepthOptions {
frequency?: number;
depth?: number;
}

RotationOptions​

Options for the rotation audio filter.

interface RotationOptions {
rotationHz?: number;
}

DistortionOptions​

Options for the distortion audio filter.

interface DistortionOptions {
sinOffset?: number;
sinScale?: number;
cosOffset?: number;
cosScale?: number;
tanOffset?: number;
tanScale?: number;
offset?: number;
scale?: number;
}

ChannelMixOptions​

Options for the channel mix audio filter.

interface ChannelMixOptions {
leftToLeft?: number;
leftToRight?: number;
rightToLeft?: number;
rightToRight?: number;
}

LowPassOptions​

Options for the low pass audio filter.

interface LowPassOptions {
smoothing?: number;
}

Track​

Represents an encoded track and its metadata.

interface Track {
encoded: string;
info: TrackInfo;
}

TrackInfo​

Detailed information about a track.

interface TrackInfo {
identifier: string;
isSeekable: boolean;
author: string;
length: number;
isStream: boolean;
position: number;
title: string;
uri?: string;
artworkUrl?: string | null;
sourceName?: string;
requester?: string;
}

LoadTrackResponse​

Response structure for track loading/searching.

interface LoadTrackResponse {
loadType: string;
data: Track[] | null;
playlistInfo?: {
name: string;
selectedTrack?: number;
};
exception?: {
message: string;
severity: string;
};
}

Event Types​

LavalinkEvent​

Represents a generic Lavalink event payload.

interface LavalinkEvent {
op: string;
type?: string;
guildId: string;
[key: string]: any;
}

NodeStats​

Statistics for a Lavalink node.

interface NodeStats {
players: number;
playingPlayers: number;
uptime: number;
memory: {
free: number;
used: number;
allocated: number;
reservable: number;
};
cpu: {
cores: number;
systemLoad: number;
lavalinkLoad: number;
};
frameStats?: {
sent: number;
nulled: number;
deficit: number;
};
}

PlayOptions​

Options for playing a track.

interface PlayOptions {
track: Track;
options?: {
noReplace?: boolean;
startTime?: number;
endTime?: number;
};
}

CustomFilter​

Represents a custom audio filter definition.

interface CustomFilter {
name: string;
description?: string;
filters: FilterOptions;
tags?: string[];
}

SearchOptions​

Options for searching tracks.

interface SearchOptions {
source?: string;
requester?: string;
context?: Record<string, any>;
}

NodeGroup​

Represents a group of Lavalink nodes.

interface NodeGroup {
name: string;
nodes: Node[];
}

LavalinkStats​

Aggregate statistics for all connected Lavalink nodes.

interface LavalinkStats extends Omit<NodeStats, 'frameStats'> {
/**
* Individual stats for each node, keyed by node name
*/
nodeStats: Record<string, NodeStats>;
}