lavalink-client 2.2.2 → 2.3.0

package/dist/cjs/structures/Types/Node.d.ts

@@ -0,0 +1,216 @@
+/// <reference types="node" />
+import type internal from "stream";
+import type { LavalinkNode } from "../Node";
+import type { DestroyReasonsType } from "./Player";
+import type { InvalidLavalinkRestRequest, LavalinkPlayer } from "./Utils";
+/** Ability to manipulate fetch requests */
+export type ModifyRequest = (options: RequestInit & {
+    path: string;
+    extraQueryUrlParams?: URLSearchParams;
+}) => void;
+export type SponsorBlockSegment = "sponsor" | "selfpromo" | "interaction" | "intro" | "outro" | "preview" | "music_offtopic" | "filler";
+/**
+ * Node Options for creating a lavalink node
+ */
+export interface LavalinkNodeOptions {
+    /** The Lavalink Server-Ip / Domain-URL */
+    host: string;
+    /** The Lavalink Connection Port */
+    port: number;
+    /** The Lavalink Password / Authorization-Key */
+    authorization: string;
+    /** Does the Server use ssl (https) */
+    secure?: boolean;
+    /** RESUME THE PLAYER? by providing a sessionid on the node-creation */
+    sessionId?: string;
+    /** Add a Custom ID to the node, for later use */
+    id?: string;
+    /** Voice Regions of this Node */
+    regions?: string[];
+    /** The retryAmount for the node. */
+    retryAmount?: number;
+    /** The retryDelay for the node. */
+    retryDelay?: number;
+    /** signal for cancelling requests - default: AbortSignal.timeout(options.requestSignalTimeoutMS || 10000) - put <= 0 to disable */
+    requestSignalTimeoutMS?: number;
+    /** Close on error */
+    closeOnError?: boolean;
+    /** Heartbeat interval , set to <= 0 to disable heartbeat system */
+    heartBeatInterval?: 30000;
+    /** Recommended, to check wether the client is still connected or not on the stats endpoint */
+    enablePingOnStatsCheck?: boolean;
+}
+/**
+ * Memory Stats object from lavalink
+ */
+export interface MemoryStats {
+    /** The free memory of the allocated amount. */
+    free: number;
+    /** The used memory of the allocated amount. */
+    used: number;
+    /** The total allocated memory. */
+    allocated: number;
+    /** The reservable memory. */
+    reservable: number;
+}
+/**
+ * CPU Stats object from lavalink
+ */
+export interface CPUStats {
+    /** The core amount the host machine has. */
+    cores: number;
+    /** The system load. */
+    systemLoad: number;
+    /** The lavalink load. */
+    lavalinkLoad: number;
+}
+/**
+ * FrameStats Object from lavalink
+ */
+export interface FrameStats {
+    /** The amount of sent frames. */
+    sent?: number;
+    /** The amount of nulled frames. */
+    nulled?: number;
+    /** The amount of deficit frames. */
+    deficit?: number;
+}
+/**
+ * BaseNodeStats object from Lavalink
+ */
+export interface BaseNodeStats {
+    /** The amount of players on the node. */
+    players: number;
+    /** The amount of playing players on the node. */
+    playingPlayers: number;
+    /** The uptime for the node. */
+    uptime: number;
+    /** The memory stats for the node. */
+    memory: MemoryStats;
+    /** The cpu stats for the node. */
+    cpu: CPUStats;
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
+}
+/**
+ * Interface for nodeStats from lavalink
+ */
+export interface NodeStats extends BaseNodeStats {
+    /** The frame stats for the node. */
+    frameStats: FrameStats;
+}
+/**
+ * Entire lavalink information object from lavalink
+ */
+export interface LavalinkInfo {
+    /** The version of this Lavalink server */
+    version: VersionObject;
+    /** The millisecond unix timestamp when this Lavalink jar was built */
+    buildTime: number;
+    /** The git information of this Lavalink server */
+    git: GitObject;
+    /** The JVM version this Lavalink server runs on */
+    jvm: string;
+    /** The Lavaplayer version being used by this server */
+    lavaplayer: string;
+    /** The enabled source managers for this server */
+    sourceManagers: string[];
+    /** The enabled filters for this server */
+    filters: string[];
+    /** The enabled plugins for this server */
+    plugins: PluginObject[];
+}
+/**
+ * Lavalink's version object from lavalink
+ */
+export interface VersionObject {
+    /** The full version string of this Lavalink server */
+    semver: string;
+    /** The major version of this Lavalink server */
+    major: number;
+    /** The minor version of this Lavalink server */
+    minor: number;
+    /** The patch version of this Lavalink server */
+    patch: internal;
+    /** The pre-release version according to semver as a . separated list of identifiers */
+    preRelease?: string;
+    /** The build metadata according to semver as a . separated list of identifiers */
+    build?: string;
+}
+/**
+ * Git information object from lavalink
+ */
+export interface GitObject {
+    /** The branch this Lavalink server was built on */
+    branch: string;
+    /** The commit this Lavalink server was built on */
+    commit: string;
+    /** The millisecond unix timestamp for when the commit was created */
+    commitTime: string;
+}
+/**
+ * Lavalink's plugins object from lavalink's plugin
+ */
+export interface PluginObject {
+    /** The name of the plugin */
+    name: string;
+    /** The version of the plugin */
+    version: string;
+}
+export type LavalinkNodeIdentifier = string;
+export interface NodeManagerEvents {
+    /**
+     * Emitted when a Node is created.
+     * @event Manager.nodeManager#create
+     */
+    "create": (node: LavalinkNode) => void;
+    /**
+     * Emitted when a Node is destroyed.
+     * @event Manager.nodeManager#destroy
+     */
+    "destroy": (node: LavalinkNode, destroyReason?: DestroyReasonsType) => void;
+    /**
+     * Emitted when a Node is connected.
+     * @event Manager.nodeManager#connect
+     */
+    "connect": (node: LavalinkNode) => void;
+    /**
+     * Emitted when a Node is reconnecting.
+     * @event Manager.nodeManager#reconnecting
+    */
+    "reconnecting": (node: LavalinkNode) => void;
+    /**
+     * Emitted When a node starts to reconnect (if you have a reconnection delay, the reconnecting event will be emitted after the retryDelay.)
+     * Useful to check wether the internal node reconnect system works or not
+     * @event Manager.nodeManager#reconnectinprogress
+     */
+    "reconnectinprogress": (node: LavalinkNode) => void;
+    /**
+     * Emitted when a Node is disconnects.
+     * @event Manager.nodeManager#disconnect
+    */
+    "disconnect": (node: LavalinkNode, reason: {
+        code?: number;
+        reason?: string;
+    }) => void;
+    /**
+     * Emitted when a Node is error.
+     * @event Manager.nodeManager#error
+    */
+    "error": (node: LavalinkNode, error: Error, payload?: unknown) => void;
+    /**
+     * Emits every single Node event.
+     * @event Manager.nodeManager#raw
+    */
+    "raw": (node: LavalinkNode, payload: unknown) => void;
+    /**
+     * Emits when the node connects resumed. You then need to create all players within this event for your usecase.
+     * Aka for that you need to be able to save player data like vc channel + text channel in a db and then sync it again
+     * @event Manager.nodeManager#nodeResumed
+     */
+    "resumed": (node: LavalinkNode, paylaod: {
+        resumed: true;
+        sessionId: string;
+        op: "ready";
+    }, players: LavalinkPlayer[] | InvalidLavalinkRestRequest) => void;
+}

package/dist/cjs/structures/Types/Node.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/structures/Types/Player.d.ts

@@ -0,0 +1,108 @@
+import type { DestroyReasons } from "../Constants";
+import type { LavalinkNode } from "../Node";
+import type { EQBand, FilterData, LavalinkFilterData } from "./Filters";
+import type { Track, UnresolvedTrack } from "./Track";
+import type { Base64, LavalinkPlayerVoiceOptions } from "./Utils";
+export type DestroyReasonsType = keyof typeof DestroyReasons | string;
+export interface PlayerJson {
+    /** Guild Id where the player was playing in */
+    guildId: string;
+    /** Options provided to the player */
+    options: PlayerOptions;
+    /** Voice Channel Id the player was playing in */
+    voiceChannelId: string;
+    /** Text Channel Id the player was synced to */
+    textChannelId?: string;
+    /** Position the player was at */
+    position: number;
+    /** Lavalink's position the player was at */
+    lastPosition: number;
+    /** Last time the position was sent from lavalink */
+    lastPositionChange: number;
+    /** Volume in % from the player (without volumeDecrementer) */
+    volume: number;
+    /** Real Volume used in lavalink (with the volumeDecrementer) */
+    lavalinkVolume: number;
+    /** The repeatmode from the player */
+    repeatMode: RepeatMode;
+    /** Pause state */
+    paused: boolean;
+    /** Wether the player was playing or not */
+    playing: boolean;
+    /** When the player was created */
+    createdTimeStamp?: number;
+    /** All current used fitlers Data */
+    filters: FilterData;
+    /** The player's ping object */
+    ping: {
+        /** Ping to the voice websocket server */
+        ws: number;
+        /** Avg. calc. Ping to the lavalink server */
+        lavalink: number;
+    };
+    /** Equalizer Bands used in lavalink */
+    equalizer: EQBand[];
+    /** The Id of the last used node */
+    nodeId?: string;
+    /** The SessionId of the node */
+    nodeSessionId?: string;
+}
+export type RepeatMode = "queue" | "track" | "off";
+export interface PlayerOptions {
+    /** Guild id of the player */
+    guildId: string;
+    /** The Voice Channel Id */
+    voiceChannelId: string;
+    /** The Text Channel Id of the Player */
+    textChannelId?: string;
+    /** instantly change volume with the one play request */
+    volume?: number;
+    /** VC Region for node selections */
+    vcRegion?: string;
+    /** if it should join deafened */
+    selfDeaf?: boolean;
+    /** If it should join muted */
+    selfMute?: boolean;
+    /** If it should use a specific lavalink node */
+    node?: LavalinkNode | string;
+    /** If when applying filters, it should use the insta apply filters fix  */
+    instaUpdateFiltersFix?: boolean;
+    /** If a volume should be applied via filters instead of lavalink-volume */
+    applyVolumeAsFilter?: boolean;
+}
+export type anyObject = {
+    [key: string | number]: string | number | null | anyObject;
+};
+export interface BasePlayOptions {
+    /** The position to start the track. */
+    position?: number;
+    /** The position to end the track. */
+    endTime?: number;
+    /** If to start "paused" */
+    paused?: boolean;
+    /** The Volume to start with */
+    volume?: number;
+    /** The Lavalink Filters to use | only with the new REST API */
+    filters?: Partial<LavalinkFilterData>;
+    /** Voice Update for Lavalink */
+    voice?: LavalinkPlayerVoiceOptions;
+}
+export interface LavalinkPlayOptions extends BasePlayOptions {
+    /** Which Track to play | don't provide, if it should pick from the Queue */
+    track?: {
+        /** The track encoded base64 string to use instead of the one from the queue system */
+        encoded?: Base64 | null;
+        /** The identifier of the track to use */
+        identifier?: string;
+        /** Custom User Data for the track to provide, will then be on the userData object from the track */
+        userData?: anyObject;
+        /** The Track requester for when u provide encodedTrack / identifer */
+        requester?: unknown;
+    };
+}
+export interface PlayOptions extends LavalinkPlayOptions {
+    /** Whether to not replace the track if a play payload is sent. */
+    noReplace?: boolean;
+    /** Adds track on queue and skips to it */
+    clientTrack?: Track | UnresolvedTrack;
+}

package/dist/cjs/structures/Types/Player.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/structures/Types/Queue.d.ts

@@ -0,0 +1,34 @@
+import type { Track, UnresolvedTrack } from "./Track";
+export interface StoredQueue {
+    current: Track | null;
+    previous: Track[];
+    tracks: (Track | UnresolvedTrack)[];
+}
+export interface QueueStoreManager extends Record<string, any> {
+    /** @async get a Value (MUST RETURN UNPARSED!) */
+    get: (guildId: unknown) => Promise<unknown>;
+    /** @async Set a value inside a guildId (MUST BE UNPARSED) */
+    set: (guildId: unknown, value: unknown) => Promise<unknown>;
+    /** @async Delete a Database Value based of it's guildId */
+    delete: (guildId: unknown) => Promise<unknown>;
+    /** @async Transform the value(s) inside of the QueueStoreManager (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
+    stringify: (value: unknown) => Promise<unknown>;
+    /** @async Parse the saved value back to the Queue (IF YOU DON'T NEED PARSING/STRINGIFY, then just return the value) */
+    parse: (value: unknown) => Promise<Partial<StoredQueue>>;
+}
+export interface ManagerQueueOptions {
+    /** Maximum Amount of tracks for the queue.previous array. Set to 0 to not save previous songs. Defaults to 25 Tracks */
+    maxPreviousTracks?: number;
+    /** Custom Queue Store option */
+    queueStore?: QueueStoreManager;
+    /** Custom Queue Watcher class */
+    queueChangesWatcher?: QueueChangesWatcher;
+}
+export interface QueueChangesWatcher {
+    /** get a Value (MUST RETURN UNPARSED!) */
+    tracksAdd: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+    /** Set a value inside a guildId (MUST BE UNPARSED) */
+    tracksRemoved: (guildId: string, tracks: (Track | UnresolvedTrack)[], position: number, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+    /** Set a value inside a guildId (MUST BE UNPARSED) */
+    shuffled: (guildId: string, oldStoredQueue: StoredQueue, newStoredQueue: StoredQueue) => void;
+}

package/dist/cjs/structures/Types/Queue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/structures/{Track.d.ts → Types/Track.d.ts}

@@ -1,5 +1,6 @@
-import { anyObject, Player } from "./Player";
-import { Base64 } from "./Utils";
+import type { Player } from "../Player";
+import type { anyObject } from "./Player";
+import type { Base64 } from "./Utils";
 /** Sourcenames provided by lavalink server */
 export type LavalinkSourceNames = "youtube" | "youtubemusic" | "soundcloud" | "bandcamp" | "twitch";
 /** Source Names provided by lava src plugin */

package/dist/cjs/structures/Types/Track.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });