lavalink-client 1.2.5 → 2.0.0

package/README.md

@@ -130,3 +130,54 @@ Check out the [Documentation](https://lc4.gitbook.io/lavalink-client) for **Exam
   - Example: `parseLavalinkConnUrl("lavalink://LavalinkNode_1:strong%23password1@localhost:2345")` will give you:
   `{ id: "LavalinkNode_1", authorization: "strong#password1", host: "localhost", port: 2345 }`
     - Note that the password "strong#password1" when encoded turns into "strong%23password1". For more information check the example bot
+
+### **Version 2.0.0**
+- Lavalink v4 released, adjusted all features from the stable release, to support it in this client!
+```diff
+
+# How to load tracks / stop playing has changed for the node.updatePlayer rest endpoint the Client handles it automatically
+- await player.node.updatePlayer({ encodedTrack?: Base64|null, track?: Track|UnresolvedTrack, identifer?: string });
++ await player.node.updatePlayer({ track: { encoded?: Base64|null, identifier?: string }, clientTrack?: Track|UnresolvedTrack });
+
+# To satisfy the changes from lavalink updatePlayer endpoint, player play also got adjusted for that (Most users won't need this feature!)
+- await player.play({ encodedTrack?: Base64|null, track?: Track|UnresolvedTrack, identifer?: string });
++ await player.play({ track: { encoded?: Base64|null, identifier?: string }, clientTrack?: Track|UnresolvedTrack });
+# However it' still recommended to do it like that:
+# first add tracks to the queue
++ await player.queue.add(Track: Track|UnresolvedTrack|(Track|UnresolvedTrack)[]);
+# then play the next track from the queue
++ await player.play();
+
+# Node Resuming got supported
+# First enable it by doing:
++ await player.node.updateResuming(true, 360_000);
+# then when reconnecting to the node add to the node.createeOptions the sessionId: "" of the previous session
+# and after  connecting the nodeManager.on("resumed", (node, payload, players) => {}) will be executed, where you can sync the players!
+
+# Node Options got adjusted # It's a property not a method should be treated readonly
++ node.resuming: { enabled: boolean, timeout: number | null }; 
+
+# Player function got added to stop playing without disconnecting
++ player.stopPlaying(clearQueue:boolean = true, executeAutoplay:boolean = false); 
+
+# Node functions for sponsorBlock Plugin (https://github.com/topi314/Sponsorblock-Plugin) got added
++ deleteSponsorBlock(player:Player)
++ setSponsorBlock(player:Player, segments: ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview", "music_offtopic", "filler"])
+# only works if you ever set the sponsor blocks once before
++ getSponsorBlock(player:Player)
+# Corresponding nodeManager events got added:
++ nodeManager.on("ChapterStarted");
++ nodeManager.on("ChaptersLoaded");
++ nodeManager.on("SegmentsLoaded");
++ nodeManager.on("SegmentSkipped");
+# Filters sending got supported for filters.pluginFilters key from lavalink api: https://lavalink.dev/api/rest.html#plugin-filters
+# Native implementation for lavaSearch plugin officially updated https://github.com/topi314/LavaSearch
+# Native implementation for lavaSrc plugin officially updated https://github.com/topi314/LavaSrc including floweryTTS
+# couple other changes, which aren't noticeable by you.
+
+# Lavalink track.userData got added (basically same feature as my custom pluginInfo.clientData system)
+# You only get the track.userData data through playerUpdate object
+```
+In one of the next updates, there will be more queueWatcher options and more custom nodeevents to trace 
+
+Most features of this update got tested, but if you encounter any bugs feel free to open an issue!

package/dist/cjs/structures/LavalinkManager.d.ts

@@ -56,6 +56,8 @@ export interface ManagerOptions {
     playerOptions?: ManagerPlayerOptions;
     /** If it should skip to the next Track on TrackEnd / TrackError etc. events */
     autoSkip?: boolean;
+    /** If it should skip to the next Track if track.resolve errors while trying to play a track. */
+    autoSkipOnResolveError?: boolean;
     /** If it should emit only new (unique) songs and not when a looping track (or similar) is plaid, default false */
     emitNewSongsOnly?: boolean;
     /** Only allow link requests with links either matching some of that regExp or including some of that string */

package/dist/cjs/structures/LavalinkManager.js

@@ -40,6 +40,7 @@ class LavalinkManager extends events_1.EventEmitter {
             linksWhitelist: options?.linksWhitelist ?? [],
             linksBlacklist: options?.linksBlacklist ?? [],
             autoSkip: options?.autoSkip ?? true,
+            autoSkipOnResolveError: options?.autoSkipOnResolveError ?? true,
             emitNewSongsOnly: options?.emitNewSongsOnly ?? false,
             queueOptions: {
                 maxPreviousTracks: options?.queueOptions?.maxPreviousTracks ?? 25,
@@ -65,6 +66,8 @@ class LavalinkManager extends events_1.EventEmitter {
         // if(typeof options?.client !== "object" || typeof options?.client.id !== "string") throw new SyntaxError("ManagerOption.client = { id: string, username?:string } was not provided, which is required");
         if (options?.autoSkip && typeof options?.autoSkip !== "boolean")
             throw new SyntaxError("ManagerOption.autoSkip must be either false | true aka boolean");
+        if (options?.autoSkipOnResolveError && typeof options?.autoSkipOnResolveError !== "boolean")
+            throw new SyntaxError("ManagerOption.autoSkipOnResolveError must be either false | true aka boolean");
         if (options?.emitNewSongsOnly && typeof options?.emitNewSongsOnly !== "boolean")
             throw new SyntaxError("ManagerOption.emitNewSongsOnly must be either false | true aka boolean");
         if (!options?.nodes || !Array.isArray(options?.nodes) || !options?.nodes.every(node => this.utils.isNodeOptions(node)))

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

@@ -78,29 +78,49 @@ export interface NodeStats extends BaseNodeStats {
     frameStats: FrameStats;
 }
 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[];
 }
 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;
 }
 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;
 }
 export interface PluginObject {
+    /** The name of the plugin */
     name: string;
+    /** The version of the plugin */
     version: string;
 }
 export declare class LavalinkNode {
@@ -110,6 +130,11 @@ export declare class LavalinkNode {
     calls: number;
     stats: NodeStats;
     sessionId?: string | null;
+    /** Wether the node resuming is enabled or not */
+    resuming: {
+        enabled: boolean;
+        timeout: number | null;
+    };
     /** Actual Lavalink Information of the Node */
     info: LavalinkInfo | null;
     /** The Node Manager of this Node */
@@ -126,10 +151,17 @@ export declare class LavalinkNode {
     private version;
     /**
      * Create a new Node
-     * @param options
-     * @param manager
+     * @param options Lavalink Node Options
+     * @param manager Node Manager
      */
     constructor(options: LavalinkNodeOptions, manager: NodeManager);
+    /**
+     * Raw Request util function
+     * @param endpoint endpoint string
+     * @param modify modify the request
+     * @returns
+     */
+    private rawRequest;
     /**
      * Makes an API call to the Node
      * @param endpoint The endpoint that we will make the call to
@@ -137,8 +169,14 @@ export declare class LavalinkNode {
      * @returns The returned data
      */
     request(endpoint: string, modify?: ModifyRequest, parseAsText?: boolean): Promise<unknown>;
+    /**
+     * Search something raw on the node, please note only add tracks to players of that node
+     * @param query SearchQuery Object
+     * @param requestUser Request User for creating the player(s)
+     * @returns Searchresult
+     */
     search(query: SearchQuery, requestUser: unknown): Promise<SearchResult>;
-    lavaSearch(query: LavaSearchQuery, requestUser: unknown): Promise<SearchResult | LavaSearchResponse>;
+    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<SearchResult | LavaSearchResponse>;
     /**
      * Update the Player State on the Lavalink Server
      * @param data
@@ -179,7 +217,7 @@ export declare class LavalinkNode {
      * @param resuming Whether resuming is enabled for this session or not
      * @param timeout The timeout in seconds (default is 60s)
      */
-    updateSession(resuming?: boolean, timeout?: number): Promise<Session>;
+    updateSession(resuming?: boolean, timeout?: number): Promise<InvalidLavalinkRestRequest | Session>;
     /**
      * Decode Track or Tracks
      */

package/dist/cjs/structures/Node.js

@@ -35,6 +35,8 @@ class LavalinkNode {
         }
     };
     sessionId = null;
+    /** Wether the node resuming is enabled or not */
+    resuming = { enabled: true, timeout: null };
     /** Actual Lavalink Information of the Node */
     info = null;
     /** The Node Manager of this Node */
@@ -51,8 +53,8 @@ class LavalinkNode {
     version = "v4";
     /**
      * Create a new Node
-     * @param options
-     * @param manager
+     * @param options Lavalink Node Options
+     * @param manager Node Manager
      */
     constructor(options, manager) {
         this.options = {
@@ -71,12 +73,12 @@ class LavalinkNode {
         Object.defineProperty(this, Utils_1.NodeSymbol, { configurable: true, value: true });
     }
     /**
-     * Makes an API call to the Node
-     * @param endpoint The endpoint that we will make the call to
-     * @param modify Used to modify the request before being sent
-     * @returns The returned data
+     * Raw Request util function
+     * @param endpoint endpoint string
+     * @param modify modify the request
+     * @returns
      */
-    async request(endpoint, modify, parseAsText = false) {
+    async rawRequest(endpoint, modify) {
         const options = {
             path: `/${this.version}/${endpoint.replace(/^\//gm, "")}`,
             method: "GET",
@@ -91,12 +93,28 @@ class LavalinkNode {
         options.path = url.pathname + url.search;
         const request = await this.rest.request(options);
         this.calls++;
+        return { request, options };
+    }
+    /**
+     * Makes an API call to the Node
+     * @param endpoint The endpoint that we will make the call to
+     * @param modify Used to modify the request before being sent
+     * @returns The returned data
+     */
+    async request(endpoint, modify, parseAsText = false) {
+        const { request, options } = await this.rawRequest(endpoint, modify);
         if (options.method === "DELETE")
             return;
         if (request.statusCode === 404)
-            throw new Error(`Node Request resulted into an error, request-URL: ${url} | headers: ${JSON.stringify(request.headers)}`);
+            throw new Error(`Node Request resulted into an error, request-PATH: ${options.path} | headers: ${JSON.stringify(request.headers)}`);
         return parseAsText ? await request.body.text() : await request.body.json();
     }
+    /**
+     * Search something raw on the node, please note only add tracks to players of that node
+     * @param query SearchQuery Object
+     * @param requestUser Request User for creating the player(s)
+     * @returns Searchresult
+     */
     async search(query, requestUser) {
         const Query = this.NodeManager.LavalinkManager.utils.transformQuery(query);
         this.NodeManager.LavalinkManager.utils.validateQueryString(this, Query.query, Query.source);
@@ -113,7 +131,7 @@ class LavalinkNode {
         else
             uri += encodeURIComponent(decodeURIComponent(Query.query));
         const res = await this.request(uri);
-        // transform the data which can be Error, Track or Track[] to enfore [Track] 
+        // transform the data which can be Error, Track or Track[] to enfore [Track]
         const resTracks = res.loadType === "playlist" ? res.data?.tracks : res.loadType === "track" ? [res.data] : res.loadType === "search" ? Array.isArray(res.data) ? res.data : [res.data] : [];
         return {
             loadType: res.loadType,
@@ -130,7 +148,7 @@ class LavalinkNode {
             tracks: (resTracks.length ? resTracks.map(t => this.NodeManager.LavalinkManager.utils.buildTrack(t, requestUser)) : [])
         };
     }
-    async lavaSearch(query, requestUser) {
+    async lavaSearch(query, requestUser, throwOnEmpty = false) {
         const Query = this.NodeManager.LavalinkManager.utils.transformLavaSearchQuery(query);
         if (Query.source)
             this.NodeManager.LavalinkManager.utils.validateSourceString(this, Query.source);
@@ -142,7 +160,10 @@ class LavalinkNode {
             throw new RangeError(`there is no lavasearch-plugin available in the lavalink node: ${this.id}`);
         if (!this.info.plugins.find(v => v.name === "lavasrc-plugin"))
             throw new RangeError(`there is no lavasrc-plugin available in the lavalink node: ${this.id}`);
-        const res = await this.request(`/loadsearch?query=${Query.source ? `${Query.source}:` : ""}${encodeURIComponent(Query.query)}${Query.types?.length ? `&types=${Query.types.join(",")}` : ""}`);
+        const { request } = await this.rawRequest(`/loadsearch?query=${Query.source ? `${Query.source}:` : ""}${encodeURIComponent(Query.query)}${Query.types?.length ? `&types=${Query.types.join(",")}` : ""}`);
+        if (throwOnEmpty === true)
+            throw new Error("Nothing found");
+        const res = (request.statusCode === 204 ? {} : await request.body.json());
         return {
             tracks: res.tracks?.map(v => this.NodeManager.LavalinkManager.utils.buildTrack(v, requestUser)) || [],
             albums: res.albums?.map(v => ({ info: v.info, pluginInfo: v?.plugin || v.pluginInfo, tracks: v.tracks.map(v => this.NodeManager.LavalinkManager.utils.buildTrack(v, requestUser)) })) || [],
@@ -165,12 +186,10 @@ class LavalinkNode {
             r.method = "PATCH";
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             r.headers["Content-Type"] = "application/json";
-            if (data.playerOptions.track)
-                delete data.playerOptions.track;
             r.body = JSON.stringify(data.playerOptions);
             if (data.noReplace) {
                 const url = new URL(`${this.poolAddress}${r.path}`);
-                url.searchParams.append("noReplace", data.noReplace?.toString() || "false");
+                url.searchParams.append("noReplace", data.noReplace === true && typeof data.noReplace === "boolean" ? "true" : "false");
                 r.path = url.pathname + url.search;
             }
         });
@@ -276,6 +295,10 @@ class LavalinkNode {
             data.resuming = resuming;
         if (typeof timeout === "number" && timeout > 0)
             data.timeout = timeout;
+        this.resuming = {
+            enabled: typeof resuming === "boolean" ? resuming : false,
+            timeout: typeof resuming === "boolean" && resuming === true ? timeout : null,
+        };
         return await this.request(`/sessions/${this.sessionId}`, r => {
             r.method = "PATCH";
             r.headers = { Authorization: this.options.authorization, 'Content-Type': 'application/json' };
@@ -326,6 +349,7 @@ class LavalinkNode {
      * @returns
      */
     async fetchVersion() {
+        // need to adjust path for no-prefix version info
         return await this.request(`/version`, r => { r.path = "/version"; }, true);
     }
     /**
@@ -560,6 +584,10 @@ class LavalinkNode {
                 break;
             case "ready": // payload: { resumed: false, sessionId: 'ytva350aevn6n9n8', op: 'ready' }
                 this.sessionId = payload.sessionId;
+                this.resuming.enabled = payload.resumed;
+                if (payload.resumed === true) {
+                    this.NodeManager.emit("resumed", this, payload, await this.fetchAllPlayers());
+                }
                 break;
             default:
                 this.NodeManager.emit("error", this, new Error(`Unexpected op "${payload.op}" with data`), payload);

package/dist/cjs/structures/NodeManager.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 import { EventEmitter } from "stream";
-import { LavalinkNode, LavalinkNodeOptions } from "./Node";
 import { LavalinkManager } from "./LavalinkManager";
-import { MiniMap } from "./Utils";
+import { LavalinkNode, LavalinkNodeOptions } from "./Node";
 import { DestroyReasonsType } from "./Player";
+import { LavalinkPlayer, MiniMap } from "./Utils";
 type LavalinkNodeIdentifier = string;
 interface NodeManagerEvents {
     /**
@@ -44,6 +44,16 @@ interface NodeManagerEvents {
      * @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[]) => void;
 }
 export declare interface NodeManager {
     on<U extends keyof NodeManagerEvents>(event: U, listener: NodeManagerEvents[U]): this;

package/dist/cjs/structures/NodeManager.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeManager = void 0;
 const stream_1 = require("stream");
 const Node_1 = require("./Node");
-const Utils_1 = require("./Utils");
 const Player_1 = require("./Player");
+const Utils_1 = require("./Utils");
 class NodeManager extends stream_1.EventEmitter {
     nodes = new Utils_1.MiniMap();
     constructor(LavalinkManager) {

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

@@ -3,7 +3,7 @@ import { LavalinkManager } from "./LavalinkManager";
 import { LavalinkNode, SponsorBlockSegment } from "./Node";
 import { Queue } from "./Queue";
 import { Track, UnresolvedTrack } from "./Track";
-import { LavalinkPlayerVoiceOptions, LavaSearchQuery, SearchQuery } from "./Utils";
+import { Base64, LavalinkPlayerVoiceOptions, LavaSearchQuery, SearchQuery } from "./Utils";
 type PlayerDestroyReasons = "QueueEmpty" | "NodeDestroy" | "NodeDeleted" | "LavalinkNoVoice" | "NodeReconnectFail" | "PlayerReconnectFail" | "Disconnected" | "ChannelDeleted" | "ReconnectAllNodes" | "DisconnectAllNodes";
 export type DestroyReasonsType = PlayerDestroyReasons | string;
 export declare const DestroyReasons: Record<PlayerDestroyReasons, PlayerDestroyReasons>;
@@ -51,27 +51,42 @@ export interface PlayerOptions {
     /** If a volume should be applied via filters instead of lavalink-volume */
     applyVolumeAsFilter?: boolean;
 }
-export interface PlayOptions {
-    /** Which Track to play | don't provide, if it should pick from the Queue */
-    track?: Track | UnresolvedTrack;
-    /** Encoded Track to use, instead of the queue system... */
-    encodedTrack?: string | null;
-    /** Encoded Track to use&search, instead of the queue system (yt only)... */
-    identifier?: string;
+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;
-    /** Whether to not replace the track if a play payload is sent. */
-    noReplace?: boolean;
     /** 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;
+    /** Which Track to play | don't provide, if it should pick from the Queue */
+    clientTrack?: Track | UnresolvedTrack;
+}
 export interface Player {
     filterManager: FilterManager;
     LavalinkManager: LavalinkManager;

package/dist/cjs/structures/Player.js

@@ -122,15 +122,38 @@ class Player {
      * Play the next track from the queue / a specific track, with playoptions for Lavalink
      * @param options
      */
-    async play(options) {
+    async play(options = {}) {
         if (this.get("internal_queueempty")) {
             clearTimeout(this.get("internal_queueempty"));
             this.set("internal_queueempty", undefined);
         }
-        if (options?.track && (this.LavalinkManager.utils.isTrack(options?.track) || this.LavalinkManager.utils.isUnresolvedTrack(options.track))) {
-            if (this.LavalinkManager.utils.isUnresolvedTrack(options.track))
-                await options.track.resolve(this);
-            await this.queue.add(options?.track, 0);
+        // if clientTrack provided, play it
+        if (options?.clientTrack && (this.LavalinkManager.utils.isTrack(options?.clientTrack) || this.LavalinkManager.utils.isUnresolvedTrack(options.clientTrack))) {
+            if (this.LavalinkManager.utils.isUnresolvedTrack(options.clientTrack))
+                await options.clientTrack.resolve(this);
+            if (typeof options.track.userData === "object")
+                options.clientTrack.userData = { ...(options?.clientTrack.userData || {}), ...(options.track.userData || {}) };
+            await this.queue.add(options?.clientTrack, 0);
+            await (0, Utils_1.queueTrackEnd)(this);
+        }
+        else if (options?.track?.encoded) {
+            // handle play encoded options manually // TODO let it resolve by lavalink!
+            const track = await this.node.decode.singleTrack(options.track?.encoded, options.track?.requester || this.queue?.current?.requester || this.queue.previous?.[0]?.requester || this.queue.tracks?.[0]?.requester || this.LavalinkManager.options.client);
+            if (typeof options.track.userData === "object")
+                track.userData = { ...(track.userData || {}), ...(options.track.userData || {}) };
+            if (track)
+                this.queue.add(track, 0);
+            await (0, Utils_1.queueTrackEnd)(this);
+        }
+        else if (options?.track?.identifier) {
+            // handle play identifier options manually // TODO let it resolve by lavalink!
+            const res = await this.search({
+                query: options?.track?.identifier
+            }, options?.track?.identifier || this.queue?.current?.requester || this.queue.previous?.[0]?.requester || this.queue.tracks?.[0]?.requester || this.LavalinkManager.options.client);
+            if (typeof options.track.userData === "object")
+                res.tracks[0].userData = { ...(res.tracks[0].userData || {}), ...(options.track.userData || {}) };
+            if (res.tracks[0])
+                this.queue.add(res.tracks[0], 0);
             await (0, Utils_1.queueTrackEnd)(this);
         }
         if (!this.queue.current && this.queue.tracks.length)
@@ -139,20 +162,22 @@ class Player {
             try {
                 // resolve the unresolved track
                 await this.queue.current.resolve(this);
+                if (typeof options.track.userData === "object")
+                    this.queue.current.userData = { ...(this.queue.current.userData || {}), ...(options.track.userData || {}) };
             }
             catch (error) {
                 this.LavalinkManager.emit("trackError", this, this.queue.current, error);
+                if (options && "clientTrack" in options)
+                    delete options.clientTrack;
                 if (options && "track" in options)
                     delete options.track;
-                if (options && "encodedTrack" in options)
-                    delete options.encodedTrack;
-                if (this.queue.tracks[0])
+                // try to play the next track if possible
+                if (this.LavalinkManager.options?.autoSkipOnResolveError === true && this.queue.tracks[0])
                     return this.play(options);
                 return this;
             }
         }
-        const track = this.queue.current;
-        if (!track)
+        if (!this.queue.current)
             throw new Error(`There is no Track in the Queue, nor provided in the PlayOptions`);
         if (typeof options?.volume === "number" && !isNaN(options?.volume)) {
             this.volume = Math.max(Math.min(options?.volume, 500), 0);
@@ -162,24 +187,27 @@ class Player {
             this.lavalinkVolume = Math.round(vol);
             options.volume = this.lavalinkVolume;
         }
-        const finalOptions = {
-            encodedTrack: track.encoded,
+        const finalOptions = Object.fromEntries(Object.entries({
+            track: {
+                encoded: this.queue.current?.encoded || null,
+                // identifier: options.identifier,
+                userData: options?.track?.userData || {},
+            },
             volume: this.lavalinkVolume,
-            position: 0,
-            ...options,
-        };
-        if ("track" in finalOptions)
-            delete finalOptions.track;
-        if ((typeof finalOptions.position !== "undefined" && isNaN(finalOptions.position)) || (typeof finalOptions.position === "number" && (finalOptions.position < 0 || finalOptions.position >= track.info.duration)))
+            position: options?.position ?? 0,
+            endTime: options?.endTime ?? undefined,
+            filters: options?.filters ?? undefined,
+            paused: options?.paused ?? undefined,
+            voice: options?.voice ?? undefined
+        }).filter(v => typeof v[1] !== "undefined"));
+        if ((typeof finalOptions.position !== "undefined" && isNaN(finalOptions.position)) || (typeof finalOptions.position === "number" && (finalOptions.position < 0 || finalOptions.position >= this.queue.current.info.duration)))
             throw new Error("PlayerOption#position must be a positive number, less than track's duration");
         if ((typeof finalOptions.volume !== "undefined" && isNaN(finalOptions.volume) || (typeof finalOptions.volume === "number" && finalOptions.volume < 0)))
             throw new Error("PlayerOption#volume must be a positive number");
-        if ((typeof finalOptions.endTime !== "undefined" && isNaN(finalOptions.endTime)) || (typeof finalOptions.endTime === "number" && (finalOptions.endTime < 0 || finalOptions.endTime >= track.info.duration)))
+        if ((typeof finalOptions.endTime !== "undefined" && isNaN(finalOptions.endTime)) || (typeof finalOptions.endTime === "number" && (finalOptions.endTime < 0 || finalOptions.endTime >= this.queue.current.info.duration)))
             throw new Error("PlayerOption#endTime must be a positive number, less than track's duration");
         if (typeof finalOptions.position === "number" && typeof finalOptions.endTime === "number" && finalOptions.endTime < finalOptions.position)
             throw new Error("PlayerOption#endTime must be bigger than PlayerOption#position");
-        if ("noReplace" in finalOptions)
-            delete finalOptions.noReplace;
         const now = performance.now();
         await this.node.updatePlayer({
             guildId: this.guildId,
@@ -305,7 +333,7 @@ class Player {
         if (!this.playing)
             return await this.play();
         const now = performance.now();
-        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { encodedTrack: null } });
+        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { track: { encoded: null } } });
         this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
         return this;
     }
@@ -325,7 +353,7 @@ class Player {
             this.set("internal_autoplayStopPlaying", undefined);
         const now = performance.now();
         // send to lavalink, that it should stop playing
-        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { encodedTrack: null } });
+        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { track: { encoded: null } } });
         this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
         return this;
     }

package/dist/cjs/structures/Track.d.ts

@@ -1,4 +1,4 @@
-import { Player } from "./Player";
+import { anyObject, Player } from "./Player";
 import { Base64 } from "./Utils";
 /** Sourcenames provided by lavalink server */
 export type LavalinkSourceNames = "youtube" | "youtubemusic" | "soundcloud" | "bandcamp" | "twitch";
@@ -89,6 +89,8 @@ export interface LavalinkTrack {
     info: LavalinkTrackInfo;
     /** Plugin Information from Lavalink */
     pluginInfo: Partial<PluginInfo>;
+    /** The userData Object from when you provide to the lavalink request */
+    userData?: anyObject;
 }
 export interface Track {
     /** The Base 64 encoded String */
@@ -99,6 +101,8 @@ export interface Track {
     pluginInfo: Partial<PluginInfo>;
     /** The Track's Requester */
     requester?: unknown;
+    /** The userData Object from when you provide to the lavalink request */
+    userData?: anyObject;
 }
 export interface UnresolvedTrackInfo extends Partial<TrackInfo> {
     /** Required */
@@ -117,6 +121,8 @@ export interface UnresolvedTrack {
     info: UnresolvedTrackInfo;
     /** Plugin Information from Lavalink */
     pluginInfo: Partial<PluginInfo>;
+    /** The userData Object from when you provide to the lavalink request */
+    userData?: anyObject;
     /** The Track's Requester */
     requester?: unknown;
 }