magmastream 2.9.0-dev.35 → 2.9.0-dev.37

package/dist/index.d.ts

@@ -7,6 +7,7 @@ import { Redis } from 'ioredis';
 import { Client as Client$1 } from 'eris';
 import { ClusterClient, ShardClient } from 'detritus-client';
 import { Client as Client$2 } from 'oceanic.js';
+import { Client as Client$3 } from 'seyfert';
 
 /** Represents an equalizer band. */
 interface Band {
@@ -30,7 +31,7 @@ declare class Rest {
     manager: Manager;
     /** Whether the node is a NodeLink. */
     isNodeLink: boolean;
-    constructor(node: Node$1, manager: Manager);
+    constructor(node: Node, manager: Manager);
     /**
      * Sets the session ID.
      * This method is used to set the session ID after a resume operation is done.
@@ -136,12 +137,463 @@ interface playOptions {
     };
 }
 
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+declare class JsonQueue implements IQueue {
+    readonly guildId: string;
+    readonly manager: Manager;
+    private basePath;
+    /**
+     * @param guildId The guild ID.
+     * @param manager The manager.
+     */
+    constructor(guildId: string, manager: Manager);
+    /**
+     * @returns The queue path.
+     */
+    private get queuePath();
+    /**
+     * @returns The current path.
+     */
+    private get currentPath();
+    /**
+     * @returns The previous path.
+     */
+    private get previousPath();
+    /**
+     * Ensures the directory exists.
+     */
+    private ensureDir;
+    /**
+     * @returns The queue.
+     */
+    private getQueue;
+    /**
+     * @param queue The queue.
+     */
+    private setQueue;
+    /**
+     * @param filePath The file path.
+     * @returns The JSON data.
+     */
+    private readJSON;
+    /**
+     * @param filePath The file path.
+     * @param data The data to write.
+     */
+    private writeJSON;
+    /**
+     * @param filePath The file path.
+     */
+    private deleteFile;
+    /**
+     * @returns The current track.
+     */
+    getCurrent(): Promise<Track | null>;
+    /**
+     * @param track The track to set.
+     */
+    setCurrent(track: Track | null): Promise<void>;
+    /**
+     * @returns The previous tracks.
+     */
+    getPrevious(): Promise<Track[]>;
+    /**
+     * @param track The track to add.
+     */
+    addPrevious(track: Track | Track[]): Promise<void>;
+    /**
+     * @param track The track to set.
+     */
+    setPrevious(track: Track | Track[]): Promise<void>;
+    /**
+     * @returns The newest track.
+     */
+    popPrevious(): Promise<Track | null>;
+    /**
+     * Clears the previous tracks.
+     */
+    clearPrevious(): Promise<void>;
+    /**
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
+     * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
+     */
+    add(track: Track | Track[], offset?: number): Promise<void>;
+    /**
+     * Removes a track from the queue.
+     * @param position The position to remove the track at.
+     * @param end The end position to remove the track at.
+     */
+    remove(position?: number): Promise<Track[]>;
+    remove(start: number, end: number): Promise<Track[]>;
+    /**
+     * Clears the queue.
+     */
+    clear(): Promise<void>;
+    /**
+     * @returns The size of the queue.
+     */
+    size(): Promise<number>;
+    /**
+     * @returns The total size of the queue.
+     */
+    totalSize(): Promise<number>;
+    /**
+     * @returns The total duration of the queue.
+     */
+    duration(): Promise<number>;
+    /**
+     * Shuffles the queue.
+     */
+    shuffle(): Promise<void>;
+    /**
+     * Shuffles the queue by user.
+     */
+    userBlockShuffle(): Promise<void>;
+    /**
+     * Shuffles the queue by round-robin.
+     */
+    roundRobinShuffle(): Promise<void>;
+    /**
+     * Removes the first track from the queue.
+     */
+    dequeue(): Promise<Track | undefined>;
+    /**
+     * Adds a track to the front of the queue.
+     */
+    enqueueFront(track: Track | Track[]): Promise<void>;
+    /**
+     * @returns The tracks in the queue.
+     */
+    getTracks(): Promise<Track[]>;
+    /**
+     * @returns The tracks in the queue from start to end.
+     */
+    getSlice(start?: number, end?: number): Promise<Track[]>;
+    /**
+     * Modifies the queue at the specified index.
+     */
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    /**
+     * Maps the queue to a new array.
+     */
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    /**
+     * Filters the queue.
+     */
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    /**
+     * Finds the first track in the queue that satisfies the provided testing function.
+     */
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    /**
+     * Tests whether at least one element in the queue passes the test implemented by the provided function.
+     */
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    /**
+     * Tests whether all elements in the queue pass the test implemented by the provided function.
+     */
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+}
+
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+declare class MemoryQueue extends Array<Track> implements IQueue {
+    /** The current track */
+    current: Track | null;
+    /** The previous tracks */
+    previous: Track[];
+    /** The Manager instance. */
+    manager: Manager;
+    /** The guild ID property. */
+    guildId: string;
+    /**
+     * Constructs a new Queue.
+     * @param guildId The guild ID.
+     * @param manager The Manager instance.
+     */
+    constructor(guildId: string, manager: Manager);
+    /**
+     * @returns The current track.
+     */
+    getCurrent(): Promise<Track | null>;
+    /**
+     * @param track The track to set.
+     */
+    setCurrent(track: Track | null): Promise<void>;
+    /**
+     * @returns The previous tracks.
+     */
+    getPrevious(): Promise<Track[]>;
+    addPrevious(track: Track | Track[]): Promise<void>;
+    /**
+     * @param tracks The tracks to set.
+     */
+    setPrevious(tracks: Track[]): Promise<void>;
+    /**
+     * @returns The newest track.
+     */
+    popPrevious(): Promise<Track | null>;
+    /**
+     * Clears the previous tracks.
+     */
+    clearPrevious(): Promise<void>;
+    /**
+     * The total duration of the queue in milliseconds.
+     * This includes the duration of the currently playing track.
+     */
+    duration(): Promise<number>;
+    /**
+     * The total size of tracks in the queue including the current track.
+     * This includes the current track if it is not null.
+     * @returns The total size of tracks in the queue including the current track.
+     */
+    totalSize(): Promise<number>;
+    /**
+     * The size of tracks in the queue.
+     * This does not include the currently playing track.
+     * @returns The size of tracks in the queue.
+     */
+    size(): Promise<number>;
+    /**
+     * Adds a track to the queue.
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
+     * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
+     */
+    add(track: Track | Track[], offset?: number): Promise<void>;
+    /**
+     * Removes track(s) from the queue.
+     * @param startOrPosition If a single number is provided, it will be treated as the position of the track to remove.
+     *                         If two numbers are provided, they will be used as the start and end of a range of tracks to remove.
+     * @param end Optional, end of the range of tracks to remove.
+     * @returns The removed track(s).
+     */
+    remove(position?: number): Promise<Track[]>;
+    remove(start: number, end: number): Promise<Track[]>;
+    /**
+     * Clears the queue.
+     * This will remove all tracks from the queue and emit a state update event.
+     */
+    clear(): Promise<void>;
+    /**
+     * Shuffles the queue.
+     * This will randomize the order of the tracks in the queue and emit a state update event.
+     */
+    shuffle(): Promise<void>;
+    /**
+     * Shuffles the queue to play tracks requested by each user one block at a time.
+     */
+    userBlockShuffle(): Promise<void>;
+    /**
+     * Shuffles the queue to play tracks requested by each user one by one.
+     */
+    roundRobinShuffle(): Promise<void>;
+    /**
+     * Removes the first element from the queue.
+     */
+    dequeue(): Promise<Track | undefined>;
+    /**
+     * Adds the specified track or tracks to the front of the queue.
+     * @param track The track or tracks to add.
+     */
+    enqueueFront(track: Track | Track[]): Promise<void>;
+    /**
+     * @returns A shallow copy of the queue.
+     */
+    getTracks(): Promise<Track[]>;
+    /**
+     * @returns A shallow copy of the queue.
+     */
+    getSlice(start?: number, end?: number): Promise<Track[]>;
+    /**
+     * Modifies the queue at the specified index.
+     * @param start The index at which to start modifying the queue.
+     * @param deleteCount The number of elements to remove from the queue.
+     * @param items The elements to add to the queue.
+     * @returns The modified queue.
+     */
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    /**
+     * @returns A new array with the results of calling a provided function on every element in the queue.
+     */
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    /**
+     * @returns A new array with all elements that pass the test implemented by the provided function.
+     */
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    /**
+     * @returns The first element in the queue that satisfies the provided testing function.
+     */
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    /**
+     * @returns Whether at least one element in the queue satisfies the provided testing function.
+     */
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    /**
+     * @returns Whether all elements in the queue satisfy the provided testing function.
+     */
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+}
+
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+declare class RedisQueue implements IQueue {
+    readonly guildId: string;
+    readonly manager: Manager;
+    /**
+     * The Redis instance.
+     */
+    private redis;
+    /**
+     * The prefix for the Redis keys.
+     */
+    redisPrefix: string;
+    /**
+     * Constructs a new RedisQueue.
+     * @param guildId The guild ID.
+     * @param manager The Manager instance.
+     */
+    constructor(guildId: string, manager: Manager);
+    /**
+     * @returns The queue key.
+     */
+    private get queueKey();
+    /**
+     * @returns The current key.
+     */
+    private get currentKey();
+    /**
+     * @returns The previous key.
+     */
+    private get previousKey();
+    /**
+     * Helper to serialize/deserialize Track
+     */
+    private serialize;
+    /**
+     * Helper to serialize/deserialize Track
+     */
+    private deserialize;
+    /**
+     * @returns The current track.
+     */
+    getCurrent(): Promise<Track | null>;
+    /**
+     * @param track The track to set.
+     */
+    setCurrent(track: Track | null): Promise<void>;
+    /**
+     * @returns The previous tracks.
+     */
+    getPrevious(): Promise<Track[]>;
+    /**
+     * @param track The track to add.
+     */
+    addPrevious(track: Track | Track[]): Promise<void>;
+    /**
+     * @param track The track to set.
+     */
+    setPrevious(track: Track | Track[]): Promise<void>;
+    /**
+     * @returns The newest track.
+     */
+    popPrevious(): Promise<Track | null>;
+    /**
+     * Clears the previous tracks.
+     */
+    clearPrevious(): Promise<void>;
+    /**
+     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
+     * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
+     */
+    add(track: Track | Track[], offset?: number): Promise<void>;
+    /**
+     * @param position The position to remove the track at.
+     * @param end The end position to remove the track at.
+     */
+    remove(position?: number): Promise<Track[]>;
+    remove(start: number, end: number): Promise<Track[]>;
+    /**
+     * Clears the queue.
+     */
+    clear(): Promise<void>;
+    /**
+     * @returns The size of the queue.
+     */
+    size(): Promise<number>;
+    /**
+     * @returns The total size of tracks in the queue including the current track.
+     */
+    totalSize(): Promise<number>;
+    /**
+     * @returns The total duration of the queue in milliseconds.
+     * This includes the duration of the currently playing track.
+     */
+    duration(): Promise<number>;
+    /**
+     * Shuffles the queue.
+     */
+    shuffle(): Promise<void>;
+    /**
+     * Shuffles the queue, but keeps the tracks of the same user together.
+     */
+    userBlockShuffle(): Promise<void>;
+    /**
+     * Shuffles the queue round-robin style.
+     */
+    roundRobinShuffle(): Promise<void>;
+    /**
+     * Removes the first track from the queue.
+     */
+    dequeue(): Promise<Track | undefined>;
+    /**
+     * Adds a track to the front of the queue.
+     */
+    enqueueFront(track: Track | Track[]): Promise<void>;
+    /**
+     * @returns The tracks in the queue.
+     */
+    getTracks(): Promise<Track[]>;
+    /**
+     * @returns The tracks in the queue from the start to the end.
+     */
+    getSlice(start?: number, end?: number): Promise<Track[]>;
+    /**
+     * Modifies the queue at the specified index.
+     */
+    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
+    /**
+     * @returns The tracks in the queue after the specified index.
+     */
+    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
+    /**
+     * @returns The tracks in the queue that match the specified condition.
+     */
+    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
+    /**
+     * @returns The first track in the queue that matches the specified condition.
+     */
+    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
+    /**
+     * @returns Whether any tracks in the queue match the specified condition.
+     */
+    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    /**
+     * @returns Whether all tracks in the queue match the specified condition.
+     */
+    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+}
+
 /**
  * State Storage Enum
  */
 declare enum StateStorageType {
-    Collection = "collection",
-    Redis = "redis"
+    Memory = "memory",
+    Redis = "redis",
+    JSON = "json"
 }
 /**
  * AutoPlay Platform Enum
@@ -173,7 +625,19 @@ declare enum LoadTypes {
     Playlist = "playlist",
     Search = "search",
     Empty = "empty",
-    Error = "error"
+    Error = "error",
+    /** Nodelink */
+    Album = "album",
+    /** Nodelink */
+    Artist = "artist",
+    /** Nodelink */
+    Station = "station",
+    /** Nodelink */
+    Podcast = "podcast",
+    /** Nodelink */
+    Show = "show",
+    /** Nodelink */
+    Short = "short"
 }
 /**
  * Search Platform Enum
@@ -291,10 +755,15 @@ declare enum ManagerEventTypes {
     TrackError = "trackError",
     TrackStart = "trackStart",
     TrackStuck = "trackStuck",
+    /** Nodelink */
     VoiceReceiverDisconnect = "voiceReceiverDisconnect",
+    /** Nodelink */
     VoiceReceiverConnect = "voiceReceiverConnect",
+    /** Nodelink */
     VoiceReceiverError = "voiceReceiverError",
+    /** Nodelink */
     VoiceReceiverStartSpeaking = "voiceReceiverStartSpeaking",
+    /** Nodelink */
     VoiceReceiverEndSpeaking = "voiceReceiverEndSpeaking"
 }
 /**
@@ -330,90 +799,26 @@ declare enum SponsorBlockSegment {
 }
 
 /**
- * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ * Base abstract class for all plugins.
+ * Users must extend this and implement load and unload methods.
  */
-declare class Queue extends Array<Track> implements IQueue {
-    /** The current track */
-    current: Track | null;
-    /** The previous tracks */
-    previous: Track[];
-    /** The Manager instance. */
-    manager: Manager;
-    /** The guild ID property. */
-    guildId: string;
-    /**
-     * Constructs a new Queue.
-     * @param guildId The guild ID.
-     * @param manager The Manager instance.
-     */
-    constructor(guildId: string, manager: Manager);
-    getCurrent(): Promise<Track | null>;
-    setCurrent(track: Track | null): Promise<void>;
-    getPrevious(): Promise<Track[]>;
-    addPrevious(track: Track | Track[]): Promise<void>;
-    setPrevious(tracks: Track[]): Promise<void>;
-    popPrevious(): Promise<Track | null>;
-    clearPrevious(): Promise<void>;
-    /**
-     * The total duration of the queue in milliseconds.
-     * This includes the duration of the currently playing track.
-     */
-    duration(): Promise<number>;
-    /**
-     * The total size of tracks in the queue including the current track.
-     * This includes the current track if it is not null.
-     * @returns The total size of tracks in the queue including the current track.
-     */
-    totalSize(): Promise<number>;
-    /**
-     * The size of tracks in the queue.
-     * This does not include the currently playing track.
-     * @returns The size of tracks in the queue.
-     */
-    size(): Promise<number>;
-    /**
-     * Adds a track to the queue.
-     * @param track The track or tracks to add. Can be a single `Track` or an array of `Track`s.
-     * @param [offset=null] The position to add the track(s) at. If not provided, the track(s) will be added at the end of the queue.
-     */
-    add(track: Track | Track[], offset?: number): Promise<void>;
-    /**
-     * Removes track(s) from the queue.
-     * @param startOrPosition If a single number is provided, it will be treated as the position of the track to remove.
-     *                         If two numbers are provided, they will be used as the start and end of a range of tracks to remove.
-     * @param end Optional, end of the range of tracks to remove.
-     * @returns The removed track(s).
-     */
-    remove(position?: number): Promise<Track[]>;
-    remove(start: number, end: number): Promise<Track[]>;
-    /**
-     * Clears the queue.
-     * This will remove all tracks from the queue and emit a state update event.
-     */
-    clear(): Promise<void>;
+declare abstract class Plugin {
+    readonly name: string;
     /**
-     * Shuffles the queue.
-     * This will randomize the order of the tracks in the queue and emit a state update event.
+     * @param name The name of the plugin
      */
-    shuffle(): Promise<void>;
+    constructor(name: string);
     /**
-     * Shuffles the queue to play tracks requested by each user one block at a time.
+     * Load the plugin.
+     * @param manager The MagmaStream Manager instance
      */
-    userBlockShuffle(): Promise<void>;
+    abstract load(manager: Manager): void;
     /**
-     * Shuffles the queue to play tracks requested by each user one by one.
+     * Unload the plugin.
+     * Called on shutdown to gracefully cleanup resources or detach listeners.
+     * @param manager The MagmaStream Manager instance
      */
-    roundRobinShuffle(): Promise<void>;
-    dequeue(): Promise<Track | undefined>;
-    enqueueFront(track: Track | Track[]): Promise<void>;
-    getTracks(): Promise<Track[]>;
-    getSlice(start?: number, end?: number): Promise<Track[]>;
-    modifyAt(start: number, deleteCount?: number, ...items: Track[]): Promise<Track[]>;
-    mapAsync<T>(callback: (track: Track, index: number, array: Track[]) => T): Promise<T[]>;
-    filterAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track[]>;
-    findAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<Track | undefined>;
-    someAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
-    everyAsync(callback: (track: Track, index: number, array: Track[]) => boolean): Promise<boolean>;
+    abstract unload(manager: Manager): void;
 }
 
 /**
@@ -422,41 +827,61 @@ declare class Queue extends Array<Track> implements IQueue {
 interface ManagerOptions {
     /** The state storage options.
      *
-     * @default { type: StateStorageType.Collection }
+     * @default { type: StateStorageType.Collection, deleteInactivePlayers: true }
      */
     stateStorage?: StateStorageOptions;
-    /** Enable priority mode over least player count or load balancing? */
+    /** Enable priority mode over least player count or load balancing?
+     * @default false
+     */
     enablePriorityMode?: boolean;
-    /** Automatically play the next track when the current one ends. */
+    /** Automatically play the next track when the current one ends.
+     * @default true
+     */
     playNextOnEnd?: boolean;
     /** An array of search platforms to use for autoplay. First to last matters
      * Use enum `AutoPlayPlatform`.
+     * @default [AutoPlayPlatform.YouTube]
      */
     autoPlaySearchPlatforms?: AutoPlayPlatform[];
     /** The client ID to use. */
     clientId?: string;
-    /** Value to use for the `Client-Name` header. */
+    /** Value to use for the `Client-Name` header.
+     *  @default "Magmastream"
+     *
+     * For NodeLink, leave it empty.
+     */
     clientName?: string;
-    /** The array of shard IDs connected to this manager instance. */
+    /** The array of shard IDs connected to this manager instance.
+     * @default 0
+     */
     clusterId?: number;
     /** List of plugins to load. */
     enabledPlugins?: Plugin[];
     /** The default search platform to use.
-     * Use enum `SearchPlatform`. */
+     * Use enum `SearchPlatform`.
+     * @default SearchPlatform.YouTube
+     */
     defaultSearchPlatform?: SearchPlatform;
     /** The last.fm API key.
      * If you need to create one go here: https://www.last.fm/api/account/create.
      * If you already have one, get it from here: https://www.last.fm/api/accounts. */
     lastFmApiKey?: string;
-    /** The maximum number of previous tracks to store. */
+    /** The maximum number of previous tracks to store.
+     * @default 20
+     */
     maxPreviousTracks?: number;
     /** The array of nodes to connect to. */
     nodes?: NodeOptions[];
-    /** Whether the YouTube video titles should be replaced if the Author does not exactly match. */
+    /** Whether the YouTube video titles should be replaced if the Author does not exactly match.
+     * @default false
+     */
     normalizeYouTubeTitles?: boolean;
     /** An array of track properties to keep. `track` will always be present. */
     trackPartial?: TrackPartial[];
-    /** Use the least amount of players or least load? */
+    /** Use the least amount of players or least load?
+     * Use enum `UseNodeOptions`.
+     * @default UseNodeOptions.LeastPlayers
+     */
     useNode?: UseNodeOptions.LeastLoad | UseNodeOptions.LeastPlayers;
     /**
      * Function to send data to the websocket.
@@ -471,6 +896,8 @@ interface ManagerOptions {
 interface StateStorageOptions {
     type: StateStorageType;
     redisConfig?: RedisConfig;
+    jsonConfig?: JsonConfig;
+    deleteInactivePlayers?: boolean;
 }
 /**
  * Payload
@@ -485,6 +912,57 @@ interface Payload {
         self_deaf: boolean;
     };
 }
+/**
+ * Node Options
+ */
+interface NodeOptions {
+    /** The host for the node. */
+    host: string;
+    /** The port for the node.
+     * @default 2333
+     */
+    port?: number;
+    /** The password for the node.
+     * @default "youshallnotpass"
+     */
+    password?: string;
+    /** Whether the host uses SSL.
+     * @default false
+     */
+    useSSL?: boolean;
+    /** The identifier for the node.
+     * @default host
+     */
+    identifier?: string;
+    /** The maxRetryAttempts for the node.
+     * @default 30
+     */
+    maxRetryAttempts?: number;
+    /** The retryDelayMs for the node.
+     * @default 60000
+     */
+    retryDelayMs?: number;
+    /** Whether to resume the previous session.
+     * @default false
+     */
+    enableSessionResumeOption?: boolean;
+    /** The time the lavalink server will wait before it removes the player.
+     * @default 1000
+     */
+    sessionTimeoutMs?: number;
+    /** The timeout used for api calls.
+     * @default 10000
+     */
+    apiRequestTimeoutMs?: number;
+    /** Priority of the node.
+     * @default 0
+     */
+    nodePriority?: number;
+    /** Whether the node is a NodeLink.
+     * @default false
+     */
+    isNodeLink?: boolean;
+}
 /**
  * Discord Packet
  */
@@ -546,6 +1024,12 @@ interface RedisConfig {
     db?: number;
     prefix?: string;
 }
+/**
+ * JSON Configuration
+ */
+interface JsonConfig {
+    path: string;
+}
 /**
  * Player State Update Event
  */
@@ -812,6 +1296,35 @@ interface PlaylistSearchResult {
     /** The playlist info */
     playlist: PlaylistData;
 }
+interface AlbumSearchResult {
+    loadType: LoadTypes.Album;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+interface ArtistSearchResult {
+    loadType: LoadTypes.Artist;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+interface StationSearchResult {
+    loadType: LoadTypes.Station;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+interface PodcastSearchResult {
+    loadType: LoadTypes.Podcast;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+interface ShowSearchResult {
+    loadType: LoadTypes.Show;
+    tracks: Track[];
+    playlist: PlaylistData;
+}
+interface ShortSearchResult {
+    loadType: LoadTypes.Short;
+    tracks: [Track];
+}
 /**
  * Playlist Data
  */
@@ -900,7 +1413,7 @@ interface VoiceServer {
 }
 interface Extendable {
     Player: typeof Player;
-    Queue: typeof Queue;
+    Queue: typeof MemoryQueue | typeof RedisQueue | typeof JsonQueue;
     Node: typeof Node;
 }
 /**
@@ -1052,62 +1565,6 @@ interface PlayerUpdate {
         ping: number;
     };
 }
-/**
- * Node Options
- */
-interface NodeOptions {
-    /** The host for the node. */
-    host: string;
-    /** The port for the node. */
-    port?: number;
-    /** The password for the node. */
-    password?: string;
-    /** Whether the host uses SSL. */
-    useSSL?: boolean;
-    /** The identifier for the node. */
-    identifier?: string;
-    /** The maxRetryAttempts for the node. */
-    maxRetryAttempts?: number;
-    /** The retryDelayMs for the node. */
-    retryDelayMs?: number;
-    /** Whether to resume the previous session. */
-    enableSessionResumeOption?: boolean;
-    /** The time the lavalink server will wait before it removes the player. */
-    sessionTimeoutMs?: number;
-    /** The timeout used for api calls. */
-    apiRequestTimeoutMs?: number;
-    /** Priority of the node. */
-    nodePriority?: number;
-    /** Whether the node is a NodeLink. */
-    isNodeLink?: boolean;
-}
-/**
- * NodeOptions interface
- */
-interface NodeOptions {
-    /** The host for the node. */
-    host: string;
-    /** The port for the node. */
-    port?: number;
-    /** The password for the node. */
-    password?: string;
-    /** Whether the host uses SSL. */
-    useSSL?: boolean;
-    /** The identifier for the node. */
-    identifier?: string;
-    /** The maxRetryAttempts for the node. */
-    maxRetryAttempts?: number;
-    /** The retryDelayMs for the node. */
-    retryDelayMs?: number;
-    /** Whether to resume the previous session. */
-    enableSessionResumeOption?: boolean;
-    /** The time the lavalink server will wait before it removes the player. */
-    sessionTimeoutMs?: number;
-    /** The timeout used for api calls. */
-    apiRequestTimeoutMs?: number;
-    /** Priority of the node. */
-    nodePriority?: number;
-}
 /**
  * NodeStats interface
  */
@@ -1464,7 +1921,7 @@ type VoiceReceiverEvent = StartSpeakingEventVoiceReceiver | EndSpeakingEventVoic
 /**
  * Search Result Enum type
  */
-type SearchResult = TrackSearchResult | SearchSearchResult | PlaylistSearchResult | ErrorOrEmptySearchResult;
+type SearchResult = TrackSearchResult | SearchSearchResult | PlaylistSearchResult | ErrorOrEmptySearchResult | AlbumSearchResult | ArtistSearchResult | StationSearchResult | PodcastSearchResult | ShowSearchResult | ShortSearchResult;
 /**
  * Lyrics Event Enum type
  */
@@ -1474,7 +1931,7 @@ type LyricsEvent = LyricsFoundEvent | LyricsNotFoundEvent | LyricsLineEvent;
  */
 type LyricsEventType = "LyricsFoundEvent" | "LyricsNotFoundEvent" | "LyricsLineEvent";
 
-declare class Node$1 {
+declare class Node {
     manager: Manager;
     options: NodeOptions;
     /** The socket for the node. */
@@ -1707,9 +2164,10 @@ declare class Node$1 {
      *
      * @param {Track} track - The track to fetch the lyrics for.
      * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
+     * @param {string} [language="en"] - The language of the lyrics.
      * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
-    getLyrics(track: Track, skipTrackSource?: boolean): Promise<Lyrics | NodeLinkGetLyrics>;
+    getLyrics(track: Track, skipTrackSource?: boolean, language?: string): Promise<Lyrics | NodeLinkGetLyrics>;
     /**
      * Subscribes to lyrics for a player.
      * @param {string} guildId - The ID of the guild to subscribe to lyrics for.
@@ -1860,12 +2318,13 @@ declare class Manager extends EventEmitter {
     /** The map of players. */
     readonly players: Collection<string, Player>;
     /** The map of nodes. */
-    readonly nodes: Collection<string, Node$1>;
+    readonly nodes: Collection<string, Node>;
     /** The options that were set. */
     readonly options: ManagerOptions;
     initiated: boolean;
     redis?: Redis;
     private _send?;
+    private loadedPlugins;
     /**
      * Initiates the Manager class.
      * @param options
@@ -1926,7 +2385,7 @@ declare class Manager extends EventEmitter {
      * @param options - The options to create the node with.
      * @returns The created node.
      */
-    createNode(options: NodeOptions): Node$1;
+    createNode(options: NodeOptions): Node;
     /**
      * Destroys a node if it exists. Emits a debug event if the node is found and destroyed.
      * @param identifier - The identifier of the node to destroy.
@@ -1987,7 +2446,7 @@ declare class Manager extends EventEmitter {
      * If `enablePriorityMode` is false and `useNode` is not set, the node with the lowest load is chosen.
      * @returns {Node} The node to use.
      */
-    get useableNode(): Node$1;
+    get useableNode(): Node;
     /**
      * Handles the shutdown of the process by saving all active players' states and optionally cleaning up inactive players.
      * This function is called when the process is about to exit.
@@ -2058,15 +2517,29 @@ declare class Manager extends EventEmitter {
      */
     serializePlayer(player: Player): Promise<Record<string, unknown>>;
     /**
-     * Checks for players that are no longer active and deletes their saved state files.
+     * Cleans up inactive players by removing their state files from the file system.
+     * This is done to prevent stale state files from accumulating on the file system.
+     */
+    cleanupInactivePlayers(): Promise<void>;
+    /**
+     * Cleans up an inactive player by removing its state files from the file system.
      * This is done to prevent stale state files from accumulating on the file system.
+     * @param guildId The guild ID of the player to clean up.
+     */
+    cleanupInactivePlayer(guildId: string): Promise<void>;
+    /**
+     * Loads the enabled plugins.
+     */
+    private loadPlugins;
+    /**
+     * Unloads the enabled plugins.
      */
-    private cleanupInactivePlayers;
+    private unloadPlugins;
     /**
      * Clears all player states from the file system.
      * This is done to prevent stale state files from accumulating on the file system.
      */
-    private clearAllPlayerStates;
+    private clearAllStoredPlayers;
     /**
      * Returns the nodes that has the least load.
      * The load is calculated by dividing the lavalink load by the number of cores.
@@ -2116,7 +2589,7 @@ declare class Player {
     /** The volume for the player */
     volume: number;
     /** The Node for the Player. */
-    node: Node$1;
+    node: Node;
     /** The guild ID for the player. */
     guildId: string;
     /** The voice channel for the player. */
@@ -2842,15 +3315,6 @@ declare enum AvailableFilters {
     Demon = "demon"
 }
 
-declare class Plugin$1 {
-    name: string;
-    /**
-     * @param name The name of the plugin
-     */
-    constructor(name: string);
-    load(manager: Manager): void;
-}
-
 declare abstract class TrackUtils {
     static trackPartial: TrackPartial[] | null;
     private static manager;
@@ -2915,6 +3379,23 @@ declare abstract class AutoPlayUtils {
      * @returns An array of recommended tracks.
      */
     static getRecommendedTracksFromSource(track: Track, platform: AutoPlayPlatform): Promise<Track[]>;
+    /**
+     * Searches for a track using the manager and returns resolved tracks.
+     * @param query The search query (artist - title).
+     * @param requester The requester who initiated the search.
+     * @returns An array of resolved tracks, or an empty array if not found or error occurred.
+     */
+    private static resolveTracksFromQuery;
+    /**
+     * Resolves the first available track from a search query using the specified source.
+     * Useful for normalizing tracks that lack platform-specific metadata or URIs.
+     *
+     * @param query - The search query string (usually "Artist - Title").
+     * @param source - The search platform to use (e.g., Spotify, Deezer, YouTube).
+     * @param requester - The requester object, used for context or attribution.
+     * @returns A single resolved {@link Track} object if found, or `null` if the search fails or returns no results.
+     */
+    private static resolveFirstTrackFromQuery;
     static buildTracksFromResponse<T>(recommendedResult: LavalinkResponse, requester?: T): Track[];
 }
 /** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
@@ -2968,5 +3449,36 @@ declare class OceanicManager extends Manager {
     protected send(packet: GatewayVoiceStateUpdate): void;
 }
 
-export { AutoPlayPlatform, AutoPlayUtils, AvailableFilters, DetritusManager, DiscordJSManager, ErisManager, Filters, LoadTypes, Manager, ManagerEventTypes, Node$1 as Node, OceanicManager, Player, PlayerStateEventTypes, Plugin$1 as Plugin, Queue, Rest, SearchPlatform, SeverityTypes, SponsorBlockSegment, StateStorageType, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
-export type { CPUStats, DiscordPacket, EndSpeakingEventVoiceReceiver, EndSpeakingEventVoiceReceiverData, EqualizerBand, ErrorOrEmptySearchResult, Exception, Extendable, FrameStats, IQueue, LavaPlayer, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsEvent, LyricsEventType, LyricsFoundEvent, LyricsLine, LyricsLineEvent, LyricsNotFoundEvent, ManagerEvents, ManagerInitOptions, ManagerOptions, MemoryStats, NodeLinkGetLyrics, NodeLinkGetLyricsEmpty, NodeLinkGetLyricsError, NodeLinkGetLyricsMultiple, NodeLinkGetLyricsSingle, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStateChangeData, PlayerStateUpdateEvent, PlayerUpdate, PlayerUpdateVoiceState, PlaylistData, PlaylistInfoData, PlaylistRawData, PlaylistSearchResult, RedisConfig, SearchQuery, SearchResult, SearchSearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, StartSpeakingEventVoiceReceiver, StartSpeakingEventVoiceReceiverData, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSearchResult, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceReceiverEvent, VoiceServer, VoiceServerUpdate, VoiceState, WebSocketClosedEvent };
+/**
+ * Seyfert wrapper for Magmastream.
+ *
+ * @note This wrapper does require the manual implementation of the "raw" and "ready" events, to call the `updateVoiceState` and `init` methods respectively.
+ *
+ * @example
+ * ```typescript
+ * const client = new Client();
+ * const manager = new SeyfertManager(client, options);
+ *
+ * client.events.values.RAW = {
+ *     data: { name: "raw" },
+ *     run: async (data) => {
+ *         await manager.updateVoiceState(data);
+ *     }
+ * }
+ *
+ * client.events.values.READY = {
+ *     data: { name: "ready" },
+ *     run: async (user, client) => {
+ *         await manager.init({ clientId: client.botId });
+ *     }
+ * }
+ * ```
+ */
+declare class SeyfertManager extends Manager {
+    readonly client: Client$3;
+    constructor(client: Client$3, options?: ManagerOptions);
+    protected send(packet: GatewayVoiceStateUpdate): void;
+}
+
+export { AutoPlayPlatform, AutoPlayUtils, AvailableFilters, DetritusManager, DiscordJSManager, ErisManager, Filters, JsonQueue, LoadTypes, Manager, ManagerEventTypes, MemoryQueue, Node, OceanicManager, Player, PlayerStateEventTypes, Plugin, RedisQueue, Rest, SearchPlatform, SeverityTypes, SeyfertManager, SponsorBlockSegment, StateStorageType, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
+export type { AlbumSearchResult, ArtistSearchResult, CPUStats, DiscordPacket, EndSpeakingEventVoiceReceiver, EndSpeakingEventVoiceReceiverData, EqualizerBand, ErrorOrEmptySearchResult, Exception, Extendable, FrameStats, IQueue, JsonConfig, LavaPlayer, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsEvent, LyricsEventType, LyricsFoundEvent, LyricsLine, LyricsLineEvent, LyricsNotFoundEvent, ManagerEvents, ManagerInitOptions, ManagerOptions, MemoryStats, NodeLinkGetLyrics, NodeLinkGetLyricsEmpty, NodeLinkGetLyricsError, NodeLinkGetLyricsMultiple, NodeLinkGetLyricsSingle, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStateChangeData, PlayerStateUpdateEvent, PlayerUpdate, PlayerUpdateVoiceState, PlaylistData, PlaylistInfoData, PlaylistRawData, PlaylistSearchResult, PodcastSearchResult, RedisConfig, SearchQuery, SearchResult, SearchSearchResult, Severity, ShortSearchResult, ShowSearchResult, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, StartSpeakingEventVoiceReceiver, StartSpeakingEventVoiceReceiverData, StateStorageOptions, StationSearchResult, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSearchResult, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceReceiverEvent, VoiceServer, VoiceServerUpdate, VoiceState, WebSocketClosedEvent };