lavalink-client 2.1.7 → 2.2.1

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

@@ -1,14 +1,19 @@
 /// <reference types="node" />
 import internal from "stream";
-import { Dispatcher, Pool } from "undici";
 import { NodeManager } from "./NodeManager";
 import { DestroyReasonsType, Player } from "./Player";
 import { Track } from "./Track";
 import { Base64, InvalidLavalinkRestRequest, LavalinkPlayer, LavaSearchQuery, LavaSearchResponse, PlayerUpdateInfo, RoutePlanner, SearchQuery, SearchResult, Session } from "./Utils";
-/** Modifies any outgoing REST requests. */
-export type ModifyRequest = (options: Dispatcher.RequestOptions) => void;
+/** Ability to manipulate fetch requests */
+export type ModifyRequest = (options: RequestInit & {
+    path: string;
+    extraQueryUrlParams?: URLSearchParams;
+}) => void;
 export declare const validSponsorBlocks: string[];
 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;
@@ -24,15 +29,16 @@ export interface LavalinkNodeOptions {
     id?: string;
     /** Voice Regions of this Node */
     regions?: string[];
-    /** Options for the undici http pool used for http requests */
-    poolOptions?: Pool.Options;
     /** The retryAmount for the node. */
     retryAmount?: number;
     /** The retryDelay for the node. */
     retryDelay?: number;
-    /** Pool Undici Options - requestTimeout */
-    requestTimeout?: number;
+    /** signal for cancelling requests - default: AbortSignal.timeout(options.requestSignalTimeoutMS || 10000) - put <= 0 to disable */
+    requestSignalTimeoutMS?: number;
 }
+/**
+ * Memory Stats object from lavalink
+ */
 export interface MemoryStats {
     /** The free memory of the allocated amount. */
     free: number;
@@ -43,6 +49,9 @@ export interface MemoryStats {
     /** The reservable memory. */
     reservable: number;
 }
+/**
+ * CPU Stats object from lavalink
+ */
 export interface CPUStats {
     /** The core amount the host machine has. */
     cores: number;
@@ -51,6 +60,9 @@ export interface CPUStats {
     /** The lavalink load. */
     lavalinkLoad: number;
 }
+/**
+ * FrameStats Object from lavalink
+ */
 export interface FrameStats {
     /** The amount of sent frames. */
     sent?: number;
@@ -59,6 +71,9 @@ export interface FrameStats {
     /** The amount of deficit frames. */
     deficit?: number;
 }
+/**
+ * BaseNodeStats object from Lavalink
+ */
 export interface BaseNodeStats {
     /** The amount of players on the node. */
     players: number;
@@ -73,10 +88,16 @@ export interface BaseNodeStats {
     /** 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;
@@ -95,6 +116,9 @@ export interface LavalinkInfo {
     /** 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;
@@ -109,6 +133,9 @@ export interface VersionObject {
     /** 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;
@@ -117,18 +144,26 @@ export interface GitObject {
     /** 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;
 }
+/**
+ * Lavalink Node creator class
+ */
 export declare class LavalinkNode {
     /** The provided Options of the Node */
     options: LavalinkNodeOptions;
     /** The amount of rest calls the node has made. */
     calls: number;
+    /** Stats from lavalink, will be updated via an interval by lavalink. */
     stats: NodeStats;
+    /** The current sessionId, only present when connected */
     sessionId?: string | null;
     /** Wether the node resuming is enabled or not */
     resuming: {
@@ -145,77 +180,205 @@ export declare class LavalinkNode {
     private reconnectAttempts;
     /** The Socket of the Lavalink */
     private socket;
-    /** The Rest Server for this Lavalink */
-    private rest;
     /** Version of what the Lavalink Server should be */
     private version;
     /**
      * Create a new Node
      * @param options Lavalink Node Options
      * @param manager Node Manager
+     *
+     *
+     * @example
+     * ```ts
+     * // don't create a node manually, instead use:
+     *
+     * client.lavalink.nodeManager.createNode(options)
+     * ```
      */
     constructor(options: LavalinkNodeOptions, manager: NodeManager);
+    /**
+     * Parse url params correctly for lavalink requests, including support for urls and uris.
+     * @param url input url object
+     * @param extraQueryUrlParams UrlSearchParams to use in a encodedURI, useful for example for flowertts
+     * @returns the url as a valid string
+     *
+     * @example
+     * ```ts
+     * player.node.getRequestingUrl(new URL(`http://localhost:2333/v4/loadtracks?identifier=Never gonna give you up`));
+     * ```
+     */
+    private getRequestingUrl;
     /**
      * Raw Request util function
      * @param endpoint endpoint string
      * @param modify modify the request
-     * @returns
+     * @param extraQueryUrlParams UrlSearchParams to use in a encodedURI, useful for example for flowertts
+     * @returns object containing request and option information
+     *
+     * @example
+     * ```ts
+     * player.node.rawRequest(`/loadtracks?identifier=Never gonna give you up`, (options) => options.method = "GET");
+     * ```
      */
     private rawRequest;
     /**
-     * Makes an API call to the Node
+     * Makes an API call to the Node. Should only be used for manual parsing like for not supported plugins
      * @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
+     *
+     * @example
+     * ```ts
+     * player.node.request(`/loadtracks?identifier=Never gonna give you up`, (options) => options.method = "GET", false);
+     * ```
      */
-    request(endpoint: string, modify?: ModifyRequest, parseAsText?: boolean): Promise<unknown>;
+    request(endpoint: string, modify?: ModifyRequest, parseAsText?: boolean): Promise<any>;
     /**
      * 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)
+     * @param throwOnEmpty Wether to throw on an empty result or not
      * @returns Searchresult
+     *
+     * @example
+     * ```ts
+     * // use player.search() instead
+     * player.node.search({ query: "Never gonna give you up by Rick Astley", source: "soundcloud" }, interaction.user);
+     * player.node.search({ query: "https://deezer.com/track/123456789" }, interaction.user);
+     * ```
+     */
+    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<SearchResult>;
+    /**
+     * Search something using the lavaSearchPlugin (filtered searches by types)
+     * @param query LavaSearchQuery Object
+     * @param requestUser Request User for creating the player(s)
+     * @param throwOnEmpty Wether to throw on an empty result or not
+     * @returns LavaSearchresult
+     *
+     * @example
+     * ```ts
+     * // use player.search() instead
+     * player.node.lavaSearch({ types: ["playlist", "album"], query: "Rick Astley", source: "spotify" }, interaction.user);
+     * ```
      */
-    search(query: SearchQuery, requestUser: unknown): Promise<SearchResult>;
     lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<SearchResult | LavaSearchResponse>;
     /**
      * Update the Player State on the Lavalink Server
-     * @param data
-     * @returns
+     * @param data data to send to lavalink and sync locally
+     * @returns result from lavalink
+     *
+     * @example
+     * ```ts
+     * // use player.search() instead
+     * player.node.updatePlayer({ guildId: player.guildId, playerOptions: { paused: true } }); // example to pause it
+     * ```
      */
     updatePlayer(data: PlayerUpdateInfo): Promise<LavalinkPlayer>;
     /**
      * Destroys the Player on the Lavalink Server
      * @param guildId
-     * @returns
+     * @returns request result
+     *
+     * @example
+     * ```ts
+     * // use player.destroy() instead
+     * player.node.destroyPlayer(player.guildId);
+     * ```
      */
-    destroyPlayer(guildId: any): Promise<unknown>;
+    destroyPlayer(guildId: any): Promise<any>;
     /**
      * Connect to the Lavalink Node
      * @param sessionId Provide the Session Id of the previous connection, to resume the node and it's player(s)
-     * @returns
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * player.node.connect(); // if provided on bootup in managerOptions#nodes, this will be called automatically when doing lavalink.init()
+     *
+     * // or connect from a resuming session:
+     * player.node.connect("sessionId");
+     * ```
      */
     connect(sessionId?: string): void;
-    /** Get the id of the node */
+    /**
+     * Get the id of the node
+     *
+     * @example
+     * ```ts
+     * const nodeId = player.node.id;
+     * console.log("node id is: ", nodeId)
+     * ```
+     */
     get id(): string;
     /**
      * Destroys the Node-Connection (Websocket) and all player's of the node
-     * @returns
+     * @param destroyReason Destroyreason to use when destroying the players
+     * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true);
+     * ```
      */
     destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean): void;
-    /** Returns if connected to the Node. */
+    /**
+     * Returns if connected to the Node.
+     *
+     * @example
+     * ```ts
+     * const isConnected = player.node.connected;
+     * console.log("node is connected: ", isConnected ? "yes" : "no")
+     * ```
+     */
     get connected(): boolean;
+    /**
+     * Returns the current ConnectionStatus
+     *
+     * @example
+     * ```ts
+     * try {
+     *     const statusOfConnection = player.node.connectionStatus;
+     *     console.log("node's connection status is:", statusOfConnection)
+     * } catch (error) {
+     *     console.error("no socket available?", error)
+     * }
+     * ```
+     */
+    get connectionStatus(): string;
     /**
      * Gets all Players of a Node
+     * @returns array of players inside of lavalink
+     *
+     * @example
+     * ```ts
+     * const node = lavalink.nodes.get("NODEID");
+     * const playersOfLavalink = await node?.fetchAllPlayers();
+     * ```
      */
     fetchAllPlayers(): Promise<LavalinkPlayer[]>;
     /**
      * Gets specific Player Information
+     * @returns lavalink player object if player exists on lavalink
+     *
+     * @example
+     * ```ts
+     * const node = lavalink.nodes.get("NODEID");
+     * const playerInformation = await node?.fetchPlayer("guildId");
+     * ```
      */
     fetchPlayer(guildId: string): Promise<LavalinkPlayer | InvalidLavalinkRestRequest>;
     /**
      * Updates the session with and enables/disables resuming and timeout
      * @param resuming Whether resuming is enabled for this session or not
      * @param timeout The timeout in seconds (default is 60s)
+     * @returns the result of the request
+     *
+     * @example
+     * ```ts
+     * const node = player.node || lavalink.nodes.get("NODEID");
+     * await node?.updateSession(true, 180e3); // will enable resuming for 180seconds
+     * ```
      */
     updateSession(resuming?: boolean, timeout?: number): Promise<InvalidLavalinkRestRequest | Session>;
     /**
@@ -223,31 +386,63 @@ export declare class LavalinkNode {
      */
     decode: {
         /**
-         * Decode a single track into its info, where BASE64 is the encoded base64 data.
-         * @param encoded
-         * @returns
+         * Decode a single track into its info
+         * @param encoded valid encoded base64 string from a track
+         * @param requester the requesteruser for building the track
+         * @returns decoded track from lavalink
+         *
+         * @example
+         * ```ts
+         * const encodedBase64 = 'QAACDgMACk5vIERpZ2dpdHkAC0JsYWNrc3RyZWV0AAAAAAAEo4AABjkxNjQ5NgABAB9odHRwczovL2RlZXplci5jb20vdHJhY2svOTE2NDk2AQBpaHR0cHM6Ly9lLWNkbnMtaW1hZ2VzLmR6Y2RuLm5ldC9pbWFnZXMvY292ZXIvZGFlN2EyNjViNzlmYjcxMjc4Y2RlMjUwNDg0OWQ2ZjcvMTAwMHgxMDAwLTAwMDAwMC04MC0wLTAuanBnAQAMVVNJUjE5NjAwOTc4AAZkZWV6ZXIBAChObyBEaWdnaXR5OiBUaGUgVmVyeSBCZXN0IE9mIEJsYWNrc3RyZWV0AQAjaHR0cHM6Ly93d3cuZGVlemVyLmNvbS9hbGJ1bS8xMDMyNTQBACJodHRwczovL3d3dy5kZWV6ZXIuY29tL2FydGlzdC8xODYxAQBqaHR0cHM6Ly9lLWNkbnMtaW1hZ2VzLmR6Y2RuLm5ldC9pbWFnZXMvYXJ0aXN0L2YxNmNhYzM2ZmVjMzkxZjczN2I3ZDQ4MmY1YWM3M2UzLzEwMDB4MTAwMC0wMDAwMDAtODAtMC0wLmpwZwEAT2h0dHBzOi8vY2RuLXByZXZpZXctYS5kemNkbi5uZXQvc3RyZWFtL2MtYTE1Yjg1NzFhYTYyMDBjMDQ0YmY1OWM3NmVkOTEyN2MtNi5tcDMAAAAAAAAAAAA=';
+         * const track = await player.node.decode.singleTrack(encodedBase64, interaction.user);
+         * ```
          */
         singleTrack: (encoded: Base64, requester: unknown) => Promise<Track>;
         /**
+         * Decodes multiple tracks into their info
+         * @param encodeds valid encoded base64 string array from all tracks
+         * @param requester the requesteruser for building the tracks
+         * @returns array of all tracks you decoded
          *
-         * @param encodeds Decodes multiple tracks into their info
-         * @returns
+         * @example
+         * ```ts
+         * const encodedBase64_1 = 'QAACDgMACk5vIERpZ2dpdHkAC0JsYWNrc3RyZWV0AAAAAAAEo4AABjkxNjQ5NgABAB9odHRwczovL2RlZXplci5jb20vdHJhY2svOTE2NDk2AQBpaHR0cHM6Ly9lLWNkbnMtaW1hZ2VzLmR6Y2RuLm5ldC9pbWFnZXMvY292ZXIvZGFlN2EyNjViNzlmYjcxMjc4Y2RlMjUwNDg0OWQ2ZjcvMTAwMHgxMDAwLTAwMDAwMC04MC0wLTAuanBnAQAMVVNJUjE5NjAwOTc4AAZkZWV6ZXIBAChObyBEaWdnaXR5OiBUaGUgVmVyeSBCZXN0IE9mIEJsYWNrc3RyZWV0AQAjaHR0cHM6Ly93d3cuZGVlemVyLmNvbS9hbGJ1bS8xMDMyNTQBACJodHRwczovL3d3dy5kZWV6ZXIuY29tL2FydGlzdC8xODYxAQBqaHR0cHM6Ly9lLWNkbnMtaW1hZ2VzLmR6Y2RuLm5ldC9pbWFnZXMvYXJ0aXN0L2YxNmNhYzM2ZmVjMzkxZjczN2I3ZDQ4MmY1YWM3M2UzLzEwMDB4MTAwMC0wMDAwMDAtODAtMC0wLmpwZwEAT2h0dHBzOi8vY2RuLXByZXZpZXctYS5kemNkbi5uZXQvc3RyZWFtL2MtYTE1Yjg1NzFhYTYyMDBjMDQ0YmY1OWM3NmVkOTEyN2MtNi5tcDMAAAAAAAAAAAA=';
+         * const encodedBase64_2 = 'QAABJAMAClRhbGsgYSBMb3QACjQwNHZpbmNlbnQAAAAAAAHr1gBxTzpodHRwczovL2FwaS12Mi5zb3VuZGNsb3VkLmNvbS9tZWRpYS9zb3VuZGNsb3VkOnRyYWNrczo4NTE0MjEwNzYvMzUyYTRiOTAtNzYxOS00M2E5LWJiOGItMjIxMzE0YzFjNjNhL3N0cmVhbS9obHMAAQAsaHR0cHM6Ly9zb3VuZGNsb3VkLmNvbS80MDR2aW5jZW50L3RhbGstYS1sb3QBADpodHRwczovL2kxLnNuZGNkbi5jb20vYXJ0d29ya3MtRTN1ek5Gc0Y4QzBXLTAtb3JpZ2luYWwuanBnAQAMUVpITkExOTg1Nzg0AApzb3VuZGNsb3VkAAAAAAAAAAA=';
+         * const tracks = await player.node.decode.multipleTracks([encodedBase64_1, encodedBase64_2], interaction.user);
+         * ```
          */
         multipleTracks: (encodeds: Base64[], requester: unknown) => Promise<Track[]>;
     };
     /**
      * Request Lavalink statistics.
-     * @returns
+     * @returns the lavalink node stats
+     *
+     * @example
+     * ```ts
+     * const lavalinkStats = await player.node.fetchStats();
+     * ```
      */
     fetchStats(): Promise<BaseNodeStats>;
     /**
      * Request Lavalink version.
-     * @returns
+     * @returns the current used lavalink version
+     *
+     * @example
+     * ```ts
+     * const lavalinkVersion = await player.node.fetchVersion();
+     * ```
      */
     fetchVersion(): Promise<string>;
     /**
      * Request Lavalink information.
-     * @returns
+     * @returns lavalink info object
+     *
+     * @example
+     * ```ts
+     * const lavalinkInfo = await player.node.fetchInfo();
+     * const availablePlugins:string[] = lavalinkInfo.plugins.map(plugin => plugin.name);
+     * const availableSources:string[] = lavalinkInfo.sourceManagers;
+     * ```
      */
     fetchInfo(): Promise<LavalinkInfo>;
     /**
@@ -255,40 +450,127 @@ export declare class LavalinkNode {
      */
     routePlannerApi: {
         /**
-         * Get routplanner Info from Lavalink
+         * Get routplanner Info from Lavalink for ip rotation
+         * @returns the status of the routeplanner
+         *
+         * @example
+         * ```ts
+         * const routePlannerStatus = await player.node.routePlannerApi.getStatus();
+         * const usedBlock = routePlannerStatus.details?.ipBlock;
+         * const currentIp = routePlannerStatus.currentAddress;
+         * ```
          */
         getStatus: () => Promise<RoutePlanner>;
         /**
-         * Release blacklisted IP address into pool of IPs
+         * Release blacklisted IP address into pool of IPs for ip rotation
          * @param address IP address
+         * @returns request data of the request
+         *
+         * @example
+         * ```ts
+         * await player.node.routePlannerApi.unmarkFailedAddress("ipv6address");
+         * ```
          */
         unmarkFailedAddress: (address: string) => Promise<void>;
         /**
          * Release all blacklisted IP addresses into pool of IPs
+         * @returns request data of the request
+         *
+         * @example
+         * ```ts
+         * await player.node.routePlannerApi.unmarkAllFailedAddresses();
+         * ```
          */
-        unmarkAllFailedAddresses: () => Promise<unknown>;
+        unmarkAllFailedAddresses: () => Promise<any>;
     };
-    /** Private Utils */
+    /** @private Utils for validating the */
     private validate;
+    /**
+     * Sync the data of the player you make an action to lavalink to
+     * @param data data to use to update the player
+     * @param res result data from lavalink, to override, if available
+     * @returns boolean
+     */
     private syncPlayerData;
-    private get poolAddress();
+    /**
+     * Get the rest Adress for making requests
+     */
+    private get restAddress();
+    /**
+     * Reconnect to the lavalink node
+     * @param instaReconnect @default false wether to instantly try to reconnect
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * await player.node.reconnect();
+     * ```
+     */
     private reconnect;
+    /** @private util function for handling opening events from websocket */
     private open;
+    /** @private util function for handling closing events from websocket */
     private close;
+    /** @private util function for handling error events from websocket */
     private error;
+    /** @private util function for handling message events from websocket */
     private message;
+    /** @private middleware util function for handling all kind of events from websocket */
     private handleEvent;
+    /** @private util function for handling trackStart event */
     private trackStart;
+    /** @private util function for handling trackEnd event */
     private trackEnd;
+    /** @private util function for handling trackStuck event */
     private trackStuck;
+    /** @private util function for handling trackError event */
     private trackError;
+    /** @private util function for handling socketClosed event */
     private socketClosed;
+    /** @private util function for handling SponsorBlock Segmentloaded event */
     private SponsorBlockSegmentLoaded;
-    private SponsorBlockSegmentkipped;
+    /** @private util function for handling SponsorBlock SegmentSkipped event */
+    private SponsorBlockSegmentSkipped;
+    /** @private util function for handling SponsorBlock Chaptersloaded event */
     private SponsorBlockChaptersLoaded;
+    /** @private util function for handling SponsorBlock Chaptersstarted event */
     private SponsorBlockChapterStarted;
+    /**
+     * Get the current sponsorblocks for the sponsorblock plugin
+     * @param player passthrough the player
+     * @returns sponsorblock seggment from lavalink
+     *
+     * @example
+     * ```ts
+     * // use it on the player via player.getSponsorBlock();
+     * const sponsorBlockSegments = await player.node.getSponsorBlock(player);
+     * ```
+     */
     getSponsorBlock(player: Player): Promise<SponsorBlockSegment[]>;
+    /**
+     * Set the current sponsorblocks for the sponsorblock plugin
+     * @param player passthrough the player
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * // use it on the player via player.setSponsorBlock();
+     * const sponsorBlockSegments = await player.node.setSponsorBlock(player, ["sponsor", "selfpromo"]);
+     * ```
+     */
     setSponsorBlock(player: Player, segments?: SponsorBlockSegment[]): Promise<void>;
+    /**
+     * Delete the sponsorblock plugins
+     * @param player passthrough the player
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * // use it on the player via player.deleteSponsorBlock();
+     * const sponsorBlockSegments = await player.node.deleteSponsorBlock(player);
+     * ```
+     */
     deleteSponsorBlock(player: Player): Promise<void>;
+    /** private util function for handling the queue end event */
     private queueEnd;
 }

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

@@ -5,7 +5,7 @@ import { LavalinkNode, LavalinkNodeOptions } from "./Node";
 import { DestroyReasonsType } from "./Player";
 import { LavalinkPlayer, MiniMap } from "./Utils";
 type LavalinkNodeIdentifier = string;
-interface NodeManagerEvents {
+export interface NodeManagerEvents {
     /**
      * Emitted when a Node is created.
      * @event Manager.nodeManager#create

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

@@ -4,28 +4,58 @@ import { LavalinkNode, SponsorBlockSegment } from "./Node";
 import { Queue } from "./Queue";
 import { Track, UnresolvedTrack } from "./Track";
 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>;
+export declare enum DestroyReasons {
+    QueueEmpty = "QueueEmpty",
+    NodeDestroy = "NodeDestroy",
+    NodeDeleted = "NodeDeleted",
+    LavalinkNoVoice = "LavalinkNoVoice",
+    NodeReconnectFail = "NodeReconnectFail",
+    Disconnected = "Disconnected",
+    PlayerReconnectFail = "PlayerReconnectFail",
+    ChannelDeleted = "ChannelDeleted",
+    DisconnectAllNodes = "DisconnectAllNodes",
+    ReconnectAllNodes = "ReconnectAllNodes"
+}
+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;
 }
 export type RepeatMode = "queue" | "track" | "off";
@@ -88,10 +118,15 @@ export interface PlayOptions extends LavalinkPlayOptions {
     clientTrack?: Track | UnresolvedTrack;
 }
 export interface Player {
+    /** Filter Manager per player */
     filterManager: FilterManager;
+    /** circular reference to the lavalink Manager from the Player for easier use */
     LavalinkManager: LavalinkManager;
+    /** Player options currently used, mutation doesn't affect player's state */
     options: PlayerOptions;
+    /** The lavalink node assigned the the player, don't change it manually */
     node: LavalinkNode;
+    /** The queue from the player */
     queue: Queue;
 }
 export declare class Player {
@@ -117,7 +152,9 @@ export declare class Player {
     /** The Volume Lavalink actually is outputting */
     lavalinkVolume: number;
     /** The current Positin of the player (Calculated) */
-    position: number;
+    get position(): number;
+    /** The timestamp when the last position change update happened */
+    lastPositionChange: number;
     /** The current Positin of the player (from Lavalink) */
     lastPosition: number;
     /** When the player was created [Timestamp in Ms] (from lavalink) */
@@ -163,7 +200,7 @@ export declare class Player {
      * @param ignoreVolumeDecrementer If it should ignore the volumedecrementer option
      */
     setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
-    lavaSearch(query: LavaSearchQuery, requestUser: unknown): Promise<import("./Utils").SearchResult | import("./Utils").LavaSearchResponse>;
+    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Utils").SearchResult | import("./Utils").LavaSearchResponse>;
     setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
     getSponsorBlock(): Promise<SponsorBlockSegment[]>;
     deleteSponsorBlock(): Promise<void>;
@@ -172,7 +209,7 @@ export declare class Player {
      * @param query Query for your data
      * @param requestUser
      */
-    search(query: SearchQuery, requestUser: unknown): Promise<import("./Utils").SearchResult | import("./Utils").UnresolvedSearchResult>;
+    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Utils").SearchResult | import("./Utils").UnresolvedSearchResult>;
     /**
      * Pause the player
      */
@@ -220,7 +257,7 @@ export declare class Player {
     /**
      * Destroy the player and disconnect from the voice channel
      */
-    destroy(reason?: string, disconnect?: boolean): Promise<this>;
+    destroy(reason?: DestroyReasons | string, disconnect?: boolean): Promise<this>;
     /**
      * Move the player on a different Audio-Node
      * @param newNode New Node / New Node Id
@@ -229,4 +266,3 @@ export declare class Player {
     /** Converts the Player including Queue to a Json state */
     toJSON(): PlayerJson;
 }
-export {};