lavalink-client 2.9.10 → 2.10.0

package/dist/index.js

@@ -339,9 +339,6 @@ var NodeLinkExclusiveEvents = [
   "LyricsNotFoundEvent"
 ];
 
-// src/structures/NodeManager.ts
-import { EventEmitter } from "events";
-
 // src/structures/Node.ts
 import { isAbsolute } from "path";
 import WebSocket from "ws";
@@ -354,6 +351,11 @@ var ReconnectionState = /* @__PURE__ */ ((ReconnectionState2) => {
   ReconnectionState2["DESTROYING"] = "DESTROYING";
   return ReconnectionState2;
 })(ReconnectionState || {});
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2["Lavalink"] = "Lavalink";
+  NodeType2["NodeLink"] = "NodeLink";
+  return NodeType2;
+})(NodeType || {});
 
 // src/structures/Utils.ts
 import { URL as URL2 } from "url";
@@ -525,12 +527,14 @@ var QueueSymbol = /* @__PURE__ */ Symbol("LC-Queue");
 var NodeSymbol = /* @__PURE__ */ Symbol("LC-Node");
 var escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 function parseLavalinkConnUrl(connectionUrl) {
-  if (!connectionUrl.startsWith("lavalink://") && !connectionUrl.startsWith("nodelink://"))
+  if (!connectionUrl) throw new Error("ConnectionUrl is required");
+  const lowered = connectionUrl.toLowerCase();
+  if (!lowered.startsWith("lavalink://") && !lowered.startsWith("nodelink://"))
     throw new Error(`ConnectionUrl (${connectionUrl}) must start with 'lavalink://' or 'nodelink://'`);
   const parsed = new URL2(connectionUrl);
   return {
     authorization: parsed.password,
-    nodeType: connectionUrl.startsWith("lavalink://") ? "Lavalink" : "NodeLink",
+    nodeType: lowered.startsWith("lavalink://") ? "Lavalink" /* Lavalink */ : "NodeLink" /* NodeLink */,
     id: parsed.username,
     host: parsed.hostname,
     port: Number(parsed.port)
@@ -1184,7 +1188,7 @@ var LavalinkNode = class _LavalinkNode {
   heartBeatPongTimestamp = 0;
   heartBeatInterval;
   pingTimeout;
-  nodeType = "Lavalink";
+  nodeType = "Lavalink" /* Lavalink */;
   isAlive = false;
   static _NodeLinkClass = null;
   /** The provided Options of the Node */
@@ -1258,7 +1262,7 @@ var LavalinkNode = class _LavalinkNode {
    * Returns wether the plugin validations are enabled or not
    */
   get _checkForPlugins() {
-    if (this.nodeType === "NodeLink") return false;
+    if (this.nodeType === "NodeLink" /* NodeLink */) return false;
     return !!this.options?.autoChecks?.pluginValidations;
   }
   /**
@@ -1328,16 +1332,17 @@ var LavalinkNode = class _LavalinkNode {
       heartBeatInterval: 3e4,
       enablePingOnStatsCheck: true,
       closeOnError: true,
+      nodeType: "Lavalink" /* Lavalink */,
       ...options,
       autoChecks: {
         sourcesValidations: options?.autoChecks?.sourcesValidations ?? true,
         pluginValidations: options?.autoChecks?.pluginValidations ?? true
       }
     };
-    if (this.options.nodeType === "NodeLink" && this.constructor.name === "LavalinkNode" && _LavalinkNode._NodeLinkClass) {
+    if (this.options.nodeType === "NodeLink" /* NodeLink */ && this.constructor.name === "LavalinkNode" && _LavalinkNode._NodeLinkClass) {
       return new _LavalinkNode._NodeLinkClass(options, manager);
     }
-    this.nodeType = this.options.nodeType || "Lavalink";
+    this.nodeType = this.options.nodeType;
     this.NodeManager = manager;
     this.validate();
     if (this.options.secure && this.options.port !== 443)
@@ -2280,20 +2285,22 @@ var LavalinkNode = class _LavalinkNode {
       throw new SyntaxError("LavalinkNode.autoChecks.pluginValidations must be either false | true aka boolean");
     if (this.options.regions !== void 0 && (!Array.isArray(this.options.regions) || !this.options.regions.every((r) => typeof r === "string")))
       throw new SyntaxError("LavalinkNode.regions must be an Array of strings");
+    if (this.options.nodeType && !NodeType[this.options.nodeType])
+      throw new SyntaxError("LavalinkNode.nodeType must be a valid NodeType enum value");
   }
   /**
    * Checks if the node is a NodeLink node
    * @returns true if the node is a NodeLink node
    */
   isNodeLink() {
-    return this.nodeType === "NodeLink";
+    return this.nodeType === "NodeLink" /* NodeLink */;
   }
   /**
    * Checks if the node is a Lavalink node
    * @returns true if the node is a Lavalink node
    */
   isLavalinkNode() {
-    return this.nodeType === "Lavalink";
+    return this.nodeType === "Lavalink" /* Lavalink */;
   }
   /**
    * Sync the data of the player you make an action to lavalink to
@@ -2679,7 +2686,7 @@ var LavalinkNode = class _LavalinkNode {
   }
   /** @private util function for handling trackStart event */
   async trackStart(player, track, payload) {
-    if (!player.get("internal_nodeChanging")) {
+    if (!player.getData("internal_nodeChanging")) {
       player.playing = true;
       player.paused = false;
     }
@@ -2707,7 +2714,7 @@ var LavalinkNode = class _LavalinkNode {
   }
   /** @private util function for handling trackEnd event */
   async trackEnd(player, track, payload) {
-    if (player.get("internal_nodeChanging") === true) return;
+    if (player.getData("internal_nodeChanging") === true) return;
     const trackToUse = track || this.getTrackOfPayload(payload);
     if (payload.reason === "replaced") {
       this._emitDebugEvent("TrackEndReplaced" /* TrackEndReplaced */, {
@@ -2718,10 +2725,10 @@ var LavalinkNode = class _LavalinkNode {
       this._LManager.emit("trackEnd", player, trackToUse, payload);
       return;
     }
-    if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
+    if (!player.queue.tracks.length && (player.repeatMode === "off" || player.getData("internal_stopPlaying")))
       return this.queueEnd(player, track, payload);
     if (["loadFailed", "cleanup"].includes(payload.reason)) {
-      if (player.get("internal_destroystatus") === true) return;
+      if (player.getData("internal_destroystatus") === true) return;
       await queueTrackEnd(player);
       if (!player.queue.current) return this.queueEnd(player, trackToUse, payload);
       this._LManager.emit("trackEnd", player, trackToUse, payload);
@@ -2730,7 +2737,7 @@ var LavalinkNode = class _LavalinkNode {
       }
       return;
     }
-    if (player.repeatMode !== "track" || player.get("internal_skipped")) await queueTrackEnd(player);
+    if (player.repeatMode !== "track" || player.getData("internal_skipped")) await queueTrackEnd(player);
     else if (trackToUse && !trackToUse?.pluginInfo?.clientData?.previousTrack) {
       player.queue.previous.unshift(trackToUse);
       if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
@@ -2738,7 +2745,7 @@ var LavalinkNode = class _LavalinkNode {
       await player.queue.utils.save();
     }
     if (!player.queue.current) return this.queueEnd(player, trackToUse, payload);
-    player.set("internal_skipped", false);
+    player.setData("internal_skipped", false);
     this._LManager.emit("trackEnd", player, trackToUse, payload);
     if (this._LManager.options.autoSkip && player.queue.current) {
       player.play({ noReplace: true });
@@ -2748,10 +2755,10 @@ var LavalinkNode = class _LavalinkNode {
   /** @private util function for handling trackStuck event */
   async trackStuck(player, track, payload) {
     if (this._LManager.options.playerOptions.maxErrorsPerTime?.threshold > 0 && this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount >= 0) {
-      const oldTimestamps = (player.get("internal_erroredTracksTimestamps") || []).filter(
+      const oldTimestamps = (player.getData("internal_erroredTracksTimestamps") || []).filter(
         (v) => Date.now() - v < this._LManager.options.playerOptions.maxErrorsPerTime?.threshold
       );
-      player.set("internal_erroredTracksTimestamps", [...oldTimestamps, Date.now()]);
+      player.setData("internal_erroredTracksTimestamps", [...oldTimestamps, Date.now()]);
       if (oldTimestamps.length >= this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount) {
         this._emitDebugEvent("TrackStuckMaxTracksErroredPerTime" /* TrackStuckMaxTracksErroredPerTime */, {
           state: "log",
@@ -2763,7 +2770,7 @@ var LavalinkNode = class _LavalinkNode {
       }
     }
     this._LManager.emit("trackStuck", player, track || this.getTrackOfPayload(payload), payload);
-    if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying"))) {
+    if (!player.queue.tracks.length && (player.repeatMode === "off" || player.getData("internal_stopPlaying"))) {
       try {
         await player.node.updatePlayer({
           guildId: player.guildId,
@@ -2786,10 +2793,10 @@ var LavalinkNode = class _LavalinkNode {
   /** @private util function for handling trackError event */
   async trackError(player, track, payload) {
     if (this._LManager.options.playerOptions.maxErrorsPerTime?.threshold > 0 && this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount >= 0) {
-      const oldTimestamps = (player.get("internal_erroredTracksTimestamps") || []).filter(
+      const oldTimestamps = (player.getData("internal_erroredTracksTimestamps") || []).filter(
         (v) => Date.now() - v < this._LManager.options.playerOptions.maxErrorsPerTime?.threshold
       );
-      player.set("internal_erroredTracksTimestamps", [...oldTimestamps, Date.now()]);
+      player.setData("internal_erroredTracksTimestamps", [...oldTimestamps, Date.now()]);
       if (oldTimestamps.length >= this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount) {
         this._emitDebugEvent("TrackErrorMaxTracksErroredPerTime" /* TrackErrorMaxTracksErroredPerTime */, {
           state: "log",
@@ -2873,7 +2880,7 @@ var LavalinkNode = class _LavalinkNode {
       };
       r.body = safeStringify(segments.map((v) => v.toLowerCase()));
     });
-    player.set(
+    player.setData(
       "internal_sponsorBlockCategories",
       segments.map((v) => v.toLowerCase())
     );
@@ -2901,7 +2908,7 @@ var LavalinkNode = class _LavalinkNode {
     await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, (r) => {
       r.method = "DELETE";
     });
-    player.set("internal_sponsorBlockCategories", []);
+    player.setData("internal_sponsorBlockCategories", []);
     this._emitDebugEvent("DeleteSponsorBlock" /* DeleteSponsorBlock */, {
       state: "log",
       message: `SponsorBlock was deleted for Player: ${player.guildId}`,
@@ -2911,26 +2918,26 @@ var LavalinkNode = class _LavalinkNode {
   }
   /** private util function for handling the queue end event */
   async queueEnd(player, track, payload) {
-    if (player.get("internal_nodeChanging") === true) return;
+    if (player.getData("internal_nodeChanging") === true) return;
     player.queue.current = null;
     player.playing = false;
-    player.set("internal_stopPlaying", void 0);
+    player.setData("internal_stopPlaying", void 0);
     this._emitDebugEvent("QueueEnded" /* QueueEnded */, {
       state: "log",
       message: `Queue Ended because no more Tracks were in the Queue, due to EventName: "${payload.type}"`,
       functionLayer: "LavalinkNode > queueEnd()"
     });
-    if (typeof this._LManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction === "function" && typeof player.get("internal_autoplayStopPlaying") === "undefined") {
+    if (typeof this._LManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction === "function" && typeof player.getData("internal_autoplayStopPlaying") === "undefined") {
       this._emitDebugEvent("AutoplayExecution" /* AutoplayExecution */, {
         state: "log",
         message: `Now Triggering Autoplay.`,
         functionLayer: "LavalinkNode > queueEnd() > autoplayFunction"
       });
-      const previousAutoplayTime = player.get("internal_previousautoplay");
+      const previousAutoplayTime = player.getData("internal_previousautoplay");
       const duration = previousAutoplayTime ? Date.now() - previousAutoplayTime : 0;
-      if (!duration || duration > this._LManager.options.playerOptions.minAutoPlayMs || !!player.get("internal_skipped")) {
+      if (!duration || duration > this._LManager.options.playerOptions.minAutoPlayMs || !!player.getData("internal_skipped")) {
         await this._LManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction(player, track);
-        player.set("internal_previousautoplay", Date.now());
+        player.setData("internal_previousautoplay", Date.now());
         if (player.queue.tracks.length > 0) await queueTrackEnd(player);
         else
           this._emitDebugEvent("AutoplayNoSongsAdded" /* AutoplayNoSongsAdded */, {
@@ -2950,8 +2957,8 @@ var LavalinkNode = class _LavalinkNode {
         });
       }
     }
-    player.set("internal_skipped", false);
-    player.set("internal_autoplayStopPlaying", void 0);
+    player.setData("internal_skipped", false);
+    player.setData("internal_autoplayStopPlaying", void 0);
     if (track && !track?.pluginInfo?.clientData?.previousTrack) {
       player.queue.previous.unshift(track);
       if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
@@ -2976,11 +2983,11 @@ var LavalinkNode = class _LavalinkNode {
           player,
           this._LManager.options.playerOptions.onEmptyQueue?.destroyAfterMs
         );
-        if (player.get("internal_queueempty")) clearTimeout(player.get("internal_queueempty"));
-        player.set(
+        if (player.getData("internal_queueempty")) clearTimeout(player.getData("internal_queueempty"));
+        player.setData(
           "internal_queueempty",
           setTimeout(() => {
-            player.set("internal_queueempty", void 0);
+            player.setData("internal_queueempty", void 0);
             if (player.queue.current) {
               return this._LManager.emit("playerQueueEmptyCancel", player);
             }
@@ -3066,13 +3073,13 @@ var LavalinkNode = class _LavalinkNode {
 
 // src/structures/NodeLink.ts
 var NodeLinkNode = class extends LavalinkNode {
-  nodeType = "NodeLink";
+  nodeType = "NodeLink" /* NodeLink */;
   constructor(options, manager) {
     super(options, manager);
-    if (this.options.nodeType === "Lavalink" && this.constructor.name === "NodeLink") {
+    if (this.options.nodeType === "Lavalink" /* Lavalink */ && (this.constructor.name === "NodeLinkNode" || this.constructor.name === "NodeLink")) {
       return new LavalinkNode(options, manager);
     }
-    this.nodeType = "NodeLink";
+    this.nodeType = "NodeLink" /* NodeLink */;
   }
   /**
    * Uses the gapless feature to set the next track to be played.
@@ -3090,6 +3097,20 @@ var NodeLinkNode = class extends LavalinkNode {
     });
     return true;
   }
+  /**
+   * Removes the nextTrackGapLess configuration
+   * @param player current player
+   * @param track if no track provided, it will use the next track from queue
+   */
+  async removeNextTrackGapLess(player) {
+    if (!this.sessionId) throw new Error("The Lavalink Node is either not ready, or not up to date!");
+    await this.updatePlayer({
+      guildId: player.guildId,
+      // @ts-expect-error - nextTrack is not a valid property of LavalinkPlayOptions but for NodeLink it is
+      playerOptions: { nextTrack: { encoded: null } }
+    });
+    return true;
+  }
   /**
    * Retrieves the meaning of a track.
    * @param track
@@ -3399,6 +3420,7 @@ var NodeLinkNode = class extends LavalinkNode {
 LavalinkNode._NodeLinkClass = NodeLinkNode;
 
 // src/structures/NodeManager.ts
+import { EventEmitter } from "events";
 var NodeManager = class extends EventEmitter {
   /**
    * Emit an event
@@ -3460,9 +3482,7 @@ var NodeManager = class extends EventEmitter {
     super();
     this.LavalinkManager = LavalinkManager2;
     if (this.LavalinkManager.options.nodes)
-      this.LavalinkManager.options.nodes.forEach((node) => {
-        this.createNode(node);
-      });
+      this.LavalinkManager.options.nodes.forEach((node) => this.createNode(node));
   }
   /**
    * Disconnects all Nodes from lavalink ws sockets
@@ -3523,9 +3543,21 @@ var NodeManager = class extends EventEmitter {
    * @returns The node that was created
    */
   createNode(options) {
+    if (options instanceof NodeLinkNode) {
+      const preExistingNode = this.nodes.get(options.id);
+      if (preExistingNode) return preExistingNode;
+      this.nodes.set(options.id, options);
+      return options;
+    }
+    if (options instanceof LavalinkNode) {
+      const preExistingNode = this.nodes.get(options.id);
+      if (preExistingNode) return preExistingNode;
+      this.nodes.set(options.id, options);
+      return options;
+    }
     if (this.nodes.has(options.id || `${options.host}:${options.port}`))
       return this.nodes.get(options.id || `${options.host}:${options.port}`);
-    const newNode = options.nodeType === "NodeLink" ? new NodeLinkNode(options, this) : new LavalinkNode(options, this);
+    const newNode = options.nodeType === "NodeLink" /* NodeLink */ ? new NodeLinkNode(options, this) : new LavalinkNode(options, this);
     this.nodes.set(newNode.id, newNode);
     return newNode;
   }
@@ -3534,48 +3566,57 @@ var NodeManager = class extends EventEmitter {
    * @param sortType The type of sorting to use
    * @returns
    */
-  leastUsedNodes(sortType = "players") {
+  leastUsedNodes(sortType = "players", filterForNodeTypes) {
+    const normalizedFilterForNodeTypes = filterForNodeTypes?.length ? filterForNodeTypes : ["Lavalink" /* Lavalink */, "NodeLink" /* NodeLink */];
     const connectedNodes = Array.from(this.nodes.values()).filter((node) => node.connected);
+    const normalizedNodeTypes = new Set(
+      normalizedFilterForNodeTypes.map(
+        (nodeTypeFilter) => Object.values(NodeType).includes(nodeTypeFilter) ? nodeTypeFilter : nodeTypeFilter.nodeType
+      )
+    );
+    const filteredConnectedNodes = connectedNodes.filter((node) => normalizedNodeTypes.has(node.nodeType));
     switch (sortType) {
       case "memory":
         {
-          return connectedNodes.sort((a, b) => (a.stats?.memory?.used || 0) - (b.stats?.memory?.used || 0));
+          return filteredConnectedNodes.sort(
+            (a, b) => (a.stats?.memory?.used || 0) - (b.stats?.memory?.used || 0)
+          );
         }
         break;
       case "cpuLavalink":
         {
-          return connectedNodes.sort(
+          return filteredConnectedNodes.sort(
             (a, b) => (a.stats?.cpu?.lavalinkLoad || 0) - (b.stats?.cpu?.lavalinkLoad || 0)
           );
         }
         break;
       case "cpuSystem":
         {
-          return connectedNodes.sort(
+          return filteredConnectedNodes.sort(
             (a, b) => (a.stats?.cpu?.systemLoad || 0) - (b.stats?.cpu?.systemLoad || 0)
           );
         }
         break;
       case "calls":
         {
-          return connectedNodes.sort((a, b) => a.calls - b.calls);
+          return filteredConnectedNodes.sort((a, b) => a.calls - b.calls);
         }
         break;
       case "playingPlayers":
         {
-          return connectedNodes.sort(
+          return filteredConnectedNodes.sort(
             (a, b) => (a.stats?.playingPlayers || 0) - (b.stats?.playingPlayers || 0)
           );
         }
         break;
       case "players":
         {
-          return connectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+          return filteredConnectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
         }
         break;
       default:
         {
-          return connectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+          return filteredConnectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
         }
         break;
     }
@@ -3608,13 +3649,22 @@ var NodeManager = class extends EventEmitter {
   }
   /**
    * Get a node from the nodeManager
-   * @param node The node to get
+   * @param node The node to get either by idetnifier, by class or by enum
    * @returns The node that was retrieved
    */
   getNode(node) {
+    if (!!node && Object.values(NodeType).includes(node)) {
+      return this.leastUsedNodes().filter((node2) => node2.nodeType === node2)[0];
+    }
+    if (!!node && node instanceof NodeLinkNode) {
+      return this.leastUsedNodes().filter((node2) => node2 instanceof NodeLinkNode)[0];
+    }
+    if (!!node && node instanceof LavalinkNode) {
+      return this.leastUsedNodes().filter((node2) => node2 instanceof LavalinkNode)[0];
+    }
     const decodeNode = typeof node === "string" ? this.nodes.get(node) : node;
     if (!decodeNode) return void 0;
-    if (decodeNode.nodeType === "NodeLink") return decodeNode;
+    if (decodeNode.nodeType === "NodeLink" /* NodeLink */) return decodeNode;
     return decodeNode;
   }
 };
@@ -3890,8 +3940,8 @@ var FilterManager = class {
     this.player.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
     return;
   }
-  privateNot0(value) {
-    return typeof value === "number" && value !== 0;
+  privateNot0(value, numToCheckAgains = 0) {
+    return typeof value === "number" && value !== numToCheckAgains;
   }
   getLavalinkFilterData() {
     return this.data.pluginFilters?.["lavalink-filter-plugin"] || {
@@ -3938,7 +3988,8 @@ var FilterManager = class {
     this.filters.lowPass = this.privateNot0(this.data.lowPass?.smoothing);
     this.filters.nodeLinkEcho = this.privateNot0(this.data.echo?.delay) || this.privateNot0(this.data.echo?.feedback) || this.privateNot0(this.data.echo?.mix);
     this.filters.nodeLinkChorus = this.privateNot0(this.data.chorus?.rate) || this.privateNot0(this.data.chorus?.depth) || this.privateNot0(this.data.chorus?.delay) || this.privateNot0(this.data.chorus?.mix) || this.privateNot0(this.data.chorus?.feedback);
-    this.filters.nodeLinkCompressor = this.privateNot0(this.data.compressor?.threshold) || this.privateNot0(this.data.compressor?.ratio) || this.privateNot0(this.data.compressor?.attack) || this.privateNot0(this.data.compressor?.release) || this.privateNot0(this.data.compressor?.gain);
+    this.filters.nodeLinkCompressor = this.privateNot0(this.data.compressor?.threshold) || this.privateNot0(this.data.compressor?.ratio, 1) || // here "1" is the default
+    this.privateNot0(this.data.compressor?.attack) || this.privateNot0(this.data.compressor?.release) || this.privateNot0(this.data.compressor?.gain);
     this.filters.nodeLinkHighPass = this.privateNot0(this.data.highPass?.smoothing);
     this.filters.nodeLinkPhaser = this.privateNot0(this.data.phaser?.stages) || this.privateNot0(this.data.phaser?.rate) || this.privateNot0(this.data.phaser?.depth) || this.privateNot0(this.data.phaser?.feedback) || this.privateNot0(this.data.phaser?.mix) || this.privateNot0(this.data.phaser?.minFrequency) || this.privateNot0(this.data.phaser?.maxFrequency);
     this.filters.nodeLinkSpatial = this.privateNot0(this.data.spatial?.depth) || this.privateNot0(this.data.spatial?.rate);
@@ -5301,7 +5352,7 @@ var Player = class {
    */
   constructor(options, LavalinkManager2, dontEmitPlayerCreateEvent) {
     if (typeof options?.customData === "object")
-      for (const [key, value] of Object.entries(options.customData)) this.set(key, value);
+      for (const [key, value] of Object.entries(options.customData)) this.setData(key, value);
     this.options = options;
     this.filterManager = new FilterManager(this);
     this.LavalinkManager = LavalinkManager2;
@@ -5410,15 +5461,15 @@ var Player = class {
    * @param options
    */
   async play(options = {}) {
-    if (this.get("internal_queueempty")) {
+    if (this.getData("internal_queueempty")) {
       this._emitDebugEvent("PlayerPlayQueueEmptyTimeoutClear" /* PlayerPlayQueueEmptyTimeoutClear */, {
         state: "log",
         message: `Player was called to play something, while there was a queueEmpty Timeout set, clearing the timeout.`,
         functionLayer: "Player > play()"
       });
       this.LavalinkManager.emit("playerQueueEmptyCancel", this);
-      clearTimeout(this.get("internal_queueempty"));
-      this.set("internal_queueempty", void 0);
+      clearTimeout(this.getData("internal_queueempty"));
+      this.setData("internal_queueempty", void 0);
     }
     if (options?.clientTrack && (this.LavalinkManager.utils.isTrack(options?.clientTrack) || this.LavalinkManager.utils.isUnresolvedTrack(options.clientTrack))) {
       if (this.LavalinkManager.utils.isUnresolvedTrack(options.clientTrack)) {
@@ -5766,7 +5817,7 @@ var Player = class {
     }
     if (!this.playing && !this.queue.current) return this.play(), this;
     const now = performance.now();
-    this.set("internal_skipped", true);
+    this.setData("internal_skipped", true);
     await this.node.updatePlayer({
       guildId: this.guildId,
       playerOptions: { track: { encoded: null }, paused: false }
@@ -5779,14 +5830,20 @@ var Player = class {
    * @returns
    */
   async stopPlaying(clearQueue = true, executeAutoplay = false) {
-    this.set("internal_stopPlaying", true);
+    this.setData("internal_stopPlaying", true);
     if (this.queue.tracks.length && clearQueue === true) await this.queue.splice(0, this.queue.tracks.length);
-    if (executeAutoplay === false) this.set("internal_autoplayStopPlaying", true);
-    else this.set("internal_autoplayStopPlaying", void 0);
+    if (executeAutoplay === false) this.setData("internal_autoplayStopPlaying", true);
+    else this.setData("internal_autoplayStopPlaying", void 0);
     const now = performance.now();
     await this.node.updatePlayer({
       guildId: this.guildId,
-      playerOptions: { track: { encoded: null } }
+      playerOptions: this.node.isNodeLink() ? {
+        track: { encoded: null },
+        // @ts-expect-error - nextTrack is not a valid property of LavalinkPlayOptions but for NodeLink it is
+        nextTrack: { encoded: null }
+      } : {
+        track: { encoded: null }
+      }
     });
     this.paused = false;
     this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
@@ -5857,11 +5914,11 @@ var Player = class {
       console.log(
         `Lavalink-Client-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Destroy-Reason: ${String(reason)}`
       );
-    if (this.get("internal_queueempty")) {
-      clearTimeout(this.get("internal_queueempty"));
-      this.set("internal_queueempty", void 0);
+    if (this.getData("internal_queueempty")) {
+      clearTimeout(this.getData("internal_queueempty"));
+      this.setData("internal_queueempty", void 0);
     }
-    if (this.get("internal_destroystatus") === true) {
+    if (this.getData("internal_destroystatus") === true) {
       this._emitDebugEvent("PlayerDestroyingSomewhereElse" /* PlayerDestroyingSomewhereElse */, {
         state: "warn",
         message: `Player is already destroying somewhere else..`,
@@ -5873,9 +5930,9 @@ var Player = class {
         );
       return;
     }
-    this.set("internal_destroystatus", true);
+    this.setData("internal_destroystatus", true);
     if (disconnect) await this.disconnect(true);
-    else this.set("internal_destroywithoutdisconnect", true);
+    else this.setData("internal_destroywithoutdisconnect", true);
     await this.queue.utils.destroy();
     this.LavalinkManager.deletePlayer(this.guildId);
     await this.node.destroyPlayer(this.guildId);
@@ -5950,7 +6007,7 @@ var Player = class {
     if (!updateNode) throw new Error("Could not find the new Node");
     if (!updateNode.connected) throw new Error("The provided Node is not active or disconnected");
     if (this.node.id === updateNode.id) throw new Error("Player is already on the provided Node");
-    if (this.get("internal_nodeChanging") === true)
+    if (this.getData("internal_nodeChanging") === true)
       throw new Error("Player is already changing the node please wait");
     if (checkSources) {
       const isDefaultSource = () => {
@@ -5988,7 +6045,7 @@ var Player = class {
     const currentTrack = this.queue.current;
     if (!this.voice.endpoint || !this.voice.sessionId || !this.voice.token)
       throw new Error("Voice Data is missing, can't change the node");
-    this.set("internal_nodeChanging", true);
+    this.setData("internal_nodeChanging", true);
     if (this.node.connected) await this.node.destroyPlayer(this.guildId);
     this.node = updateNode;
     const now = performance.now();
@@ -5996,7 +6053,7 @@ var Player = class {
       await this.connect();
       const hasSponsorBlock = !this.node._checkForPlugins || this.node.info?.plugins?.find((v) => v.name === "sponsorblock-plugin");
       if (hasSponsorBlock) {
-        const sponsorBlockCategories = this.get("internal_sponsorBlockCategories");
+        const sponsorBlockCategories = this.getData("internal_sponsorBlockCategories");
         if (Array.isArray(sponsorBlockCategories) && sponsorBlockCategories.length) {
           await this.setSponsorBlock(sponsorBlockCategories).catch((error) => {
             this._emitDebugEvent("PlayerChangeNode" /* PlayerChangeNode */, {
@@ -6047,7 +6104,7 @@ var Player = class {
       });
       throw new Error(`Failed to change the node: ${error}`);
     } finally {
-      this.set("internal_nodeChanging", void 0);
+      this.setData("internal_nodeChanging", void 0);
     }
   }
   /**
@@ -6246,9 +6303,11 @@ var LavalinkManager = class _LavalinkManager extends EventEmitter2 {
       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)))
+    if (!options?.nodes || !Array.isArray(options?.nodes) || !options?.nodes.every(
+      (node) => node instanceof NodeLinkNode || node instanceof LavalinkNode || this.utils.isNodeOptions(node)
+    ))
       throw new SyntaxError(
-        "ManagerOption.nodes must be an Array of NodeOptions and is required of at least 1 Node"
+        "ManagerOption.nodes must be an Array of NodeOptions or the Node-Classes 'NodeLinkNode' or 'LavalinkNode' and is required of at least 1 Node"
       );
     if (options?.queueOptions?.queueStore) {
       const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(options?.queueOptions?.queueStore));
@@ -6304,48 +6363,50 @@ var LavalinkManager = class _LavalinkManager extends EventEmitter2 {
    *       port: 2333,
    *       id: "testnode"
    *     },
+   *     // you can also use the util like this, and it will return a valid node option object. must start with: lavalink:// | nodelink://
+   *     // parseLavalinkConnUrl("nodelink://<nodeId>:<nodeAuthorization(Password)>@<NodeHost>:<NodePort>")
    *     sendToShard(guildId, payload) => client.guilds.cache.get(guildId)?.shard?.send(payload),
-   *     client: {
-   *       id: process.env.CLIENT_ID,
-   *       username: "TESTBOT"
-   *     },
-   *     // optional Options:
-   *     autoSkip: true,
-   *     playerOptions: {
-   *       applyVolumeAsFilter: false,
-   *       clientBasedPositionUpdateInterval: 150,
-   *       defaultSearchPlatform: "ytmsearch",
-   *       allowCustomSources: false,
-   *       volumeDecrementer: 0.75,
-   *       //requesterTransformer: YourRequesterTransformerFunction,
-   *       onDisconnect: {
-   *         autoReconnect: true,
-   *         destroyPlayer: false
-   *       },
-   *       onEmptyQueue: {
-   *         destroyAfterMs: 30_000,
-   *         //autoPlayFunction: YourAutoplayFunction,
-   *       },
-   *       useUnresolvedData: true
+   *   ],
+   *   client: {
+   *     id: process.env.CLIENT_ID,
+   *     username: "TESTBOT"
+   *   },
+   *   // optional Options:
+   *   autoSkip: true,
+   *   playerOptions: {
+   *     applyVolumeAsFilter: false,
+   *     clientBasedPositionUpdateInterval: 150,
+   *     defaultSearchPlatform: "ytmsearch",
+   *     allowCustomSources: false,
+   *     volumeDecrementer: 0.75,
+   *     //requesterTransformer: YourRequesterTransformerFunction,
+   *     onDisconnect: {
+   *       autoReconnect: true,
+   *       destroyPlayer: false
    *     },
-   *     queueOptions: {
-   *       maxPreviousTracks: 25,
-   *       //queueStore: yourCustomQueueStoreManagerClass,
-   *       //queueChangesWatcher: yourCustomQueueChangesWatcherClass
+   *     onEmptyQueue: {
+   *       destroyAfterMs: 30_000,
+   *       //autoPlayFunction: YourAutoplayFunction,
    *     },
-   *     linksBlacklist: [],
-   *     linksWhitelist: [],
-   *     advancedOptions: {
-   *       maxFilterFixDuration: 600_000,
-   *       debugOptions: {
-   *         noAudio: false,
-   *         playerDestroy: {
-   *           dontThrowError: false,
-   *           debugLogs: false
-   *         }
+   *     useUnresolvedData: true
+   *   },
+   *   queueOptions: {
+   *     maxPreviousTracks: 25,
+   *     //queueStore: yourCustomQueueStoreManagerClass,
+   *     //queueChangesWatcher: yourCustomQueueChangesWatcherClass
+   *   },
+   *   linksBlacklist: [],
+   *   linksWhitelist: [],
+   *   advancedOptions: {
+   *     maxFilterFixDuration: 600_000,
+   *     debugOptions: {
+   *       noAudio: false,
+   *       playerDestroy: {
+   *         dontThrowError: false,
+   *         debugLogs: false
    *       }
    *     }
-   *   ]
+   *   }
    * })
    * ```
    */
@@ -6437,7 +6498,7 @@ var LavalinkManager = class _LavalinkManager extends EventEmitter2 {
   deletePlayer(guildId) {
     const oldPlayer = this.getPlayer(guildId);
     if (!oldPlayer) return;
-    if (typeof oldPlayer.voiceChannelId === "string" && oldPlayer.connected && !oldPlayer.get("internal_destroywithoutdisconnect")) {
+    if (typeof oldPlayer.voiceChannelId === "string" && oldPlayer.connected && !oldPlayer.getData("internal_destroywithoutdisconnect")) {
       if (!this.options?.advancedOptions?.debugOptions?.playerDestroy?.dontThrowError)
         throw new Error(
           `Use Player#destroy() not LavalinkManager#deletePlayer() to stop the Player ${safeStringify(oldPlayer.toJSON?.())}`
@@ -6584,7 +6645,7 @@ var LavalinkManager = class _LavalinkManager extends EventEmitter2 {
         );
         return;
       }
-      if (player.get("internal_destroystatus") === true) {
+      if (player.getData("internal_destroystatus") === true) {
         this._debugNoAudio("warn", "LavalinkManager > sendRawData()", {
           message: "Player is in a destroying state. can't signal the voice states"
         });
@@ -6753,6 +6814,7 @@ export {
   NodeLinkNode,
   NodeManager,
   NodeSymbol,
+  NodeType,
   Player,
   Queue,
   QueueSaver,