magmastream 2.9.0-dev.0 → 2.9.0-dev.10

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { User, ClientUser, Message } from 'discord.js';
 import WebSocket from 'ws';
 import { Collection } from '@discordjs/collection';
 import { EventEmitter } from 'events';
+import { Redis } from 'ioredis';
 
 /** Represents an equalizer band. */
 interface Band {
@@ -200,7 +201,7 @@ declare class Node {
      * @remarks
      * If the node is already connected, this method will do nothing.
      * If the node has a session ID, it will be sent in the headers of the WebSocket connection.
-     * If the node has no session ID but the `resumeStatus` option is true, it will use the session ID
+     * If the node has no session ID but the `enableSessionResumeOption` option is true, it will use the session ID
      * stored in the sessionIds.json file if it exists.
      */
     connect(): void;
@@ -477,21 +478,21 @@ interface NodeOptions {
     /** The password for the node. */
     password?: string;
     /** Whether the host uses SSL. */
-    secure?: boolean;
+    useSSL?: boolean;
     /** The identifier for the node. */
     identifier?: string;
-    /** The retryAmount for the node. */
-    retryAmount?: number;
-    /** The retryDelay for the node. */
-    retryDelay?: number;
+    /** The maxRetryAttempts for the node. */
+    maxRetryAttempts?: number;
+    /** The retryDelayMs for the node. */
+    retryDelayMs?: number;
     /** Whether to resume the previous session. */
-    resumeStatus?: boolean;
+    enableSessionResumeOption?: boolean;
     /** The time the lavalink server will wait before it removes the player. */
-    resumeTimeout?: number;
+    sessionTimeoutMs?: number;
     /** The timeout used for api calls. */
-    requestTimeout?: number;
+    apiRequestTimeoutMs?: number;
     /** Priority of the node. */
-    priority?: number;
+    nodePriority?: number;
 }
 interface NodeStats {
     /** The amount of players on the node. */
@@ -573,24 +574,7 @@ interface Lyrics {
 /**
  * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
  */
-declare class Queue extends Array<Track> {
-    /**
-     * The total duration of the queue in milliseconds.
-     * This includes the duration of the currently playing track.
-     */
-    get duration(): 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.
-     */
-    get totalSize(): number;
-    /**
-     * The size of tracks in the queue.
-     * This does not include the currently playing track.
-     * @returns The size of tracks in the queue.
-     */
-    get size(): number;
+declare class Queue extends Array<Track> implements IQueue {
     /** The current track */
     current: Track | null;
     /** The previous tracks */
@@ -605,12 +589,34 @@ declare class Queue extends Array<Track> {
      * @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>;
+    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): void;
+    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.
@@ -618,26 +624,36 @@ declare class Queue extends Array<Track> {
      * @param end Optional, end of the range of tracks to remove.
      * @returns The removed track(s).
      */
-    remove(position?: number): Track[];
-    remove(start: number, end: number): Track[];
+    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(): void;
+    clear(): Promise<void>;
     /**
      * Shuffles the queue.
      * This will randomize the order of the tracks in the queue and emit a state update event.
      */
-    shuffle(): void;
+    shuffle(): Promise<void>;
     /**
      * Shuffles the queue to play tracks requested by each user one block at a time.
      */
-    userBlockShuffle(): void;
+    userBlockShuffle(): Promise<void>;
     /**
      * Shuffles the queue to play tracks requested by each user one by one.
      */
-    roundRobinShuffle(): void;
+    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>;
 }
 
 declare abstract class TrackUtils {
@@ -678,11 +694,26 @@ declare abstract class AutoPlayUtils {
      * @hidden
      */
     static init(manager: Manager): void;
-    static getRecommendedTracks(player: Player, track: Track, attempt?: number): Promise<Track[]>;
+    /**
+     * Gets recommended tracks for the given track.
+     * @param track The track to get recommended tracks for.
+     * @returns An array of recommended tracks.
+     */
+    static getRecommendedTracks(track: Track): Promise<Track[]>;
+    /**
+     * Gets recommended tracks from Last.fm for the given track.
+     * @param track The track to get recommended tracks for.
+     * @param apiKey The API key for Last.fm.
+     * @returns An array of recommended tracks.
+     */
     static getRecommendedTracksFromLastFm(track: Track, apiKey: string): Promise<Track[]>;
-    static getRecommendedTracksFromSource(track: Track, mappedPlatform: string): Promise<Track[]>;
-    static getRecommendedTracksFromYouTube(track: Track): Promise<Track[]>;
-    static selectPlatform(enabledSources: string[]): SearchPlatform | null;
+    /**
+     * Gets recommended tracks from the given source.
+     * @param track The track to get recommended tracks for.
+     * @param platform The source to get recommended tracks from.
+     * @returns An array of recommended tracks.
+     */
+    static getRecommendedTracksFromSource(track: Track, platform: string): Promise<Track[]>;
 }
 /** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
 declare abstract class Structure {
@@ -883,6 +914,32 @@ interface PlayerUpdate {
         ping: number;
     };
 }
+interface IQueue {
+    getCurrent(): Promise<Track | null>;
+    setCurrent(track: Track | null): Promise<void>;
+    getPrevious(): Promise<Track[]>;
+    addPrevious(track: Track | Track[]): Promise<void>;
+    clearPrevious(): Promise<void>;
+    size(): Promise<number>;
+    totalSize(): Promise<number>;
+    duration(): Promise<number>;
+    add(track: Track | Track[], offset?: number): Promise<void>;
+    remove(start?: number, end?: number): Promise<Track[]>;
+    clear(): 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[]>;
+    shuffle(): Promise<void>;
+    userBlockShuffle(): Promise<void>;
+    roundRobinShuffle(): Promise<void>;
+    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>;
+}
 
 /**
  * The main hub for interacting with Lavalink and using Magmastream,
@@ -895,14 +952,15 @@ declare class Manager extends EventEmitter {
     /** The options that were set. */
     readonly options: ManagerOptions;
     initiated: boolean;
+    redis?: Redis;
     /**
      * Initiates the Manager class.
      * @param options
-     * @param options.plugins - An array of plugins to load.
+     * @param options.enabledPlugins - An array of enabledPlugins to load.
      * @param options.nodes - An array of node options to create nodes from.
-     * @param options.autoPlay - Whether to automatically play the first track in the queue when the player is created.
-     * @param options.autoPlaySearchPlatform - The search platform autoplay will use. Fallback to Youtube if not found.
-     * @param options.usePriority - Whether to use the priority when selecting a node to play on.
+     * @param options.playNextOnEnd - Whether to automatically play the first track in the queue when the player is created.
+     * @param options.autoPlaySearchPlatforms - The search platform autoplay will use. Fallback to Youtube if not found.
+     * @param options.enablePriorityMode - Whether to use the priority when selecting a node to play on.
      * @param options.clientName - The name of the client to send to Lavalink.
      * @param options.defaultSearchPlatform - The default search platform to use when searching for tracks.
      * @param options.useNode - The strategy to use when selecting a node to play on.
@@ -926,17 +984,24 @@ declare class Manager extends EventEmitter {
      */
     search<T = unknown>(query: string | SearchQuery, requester?: T): Promise<SearchResult>;
     /**
-     * Creates a player or returns one if it already exists.
-     * @param options The options to create the player with.
-     * @returns The created player.
+     * Returns a player or undefined if it does not exist.
+     * @param guildId The guild ID of the player to retrieve.
+     * @returns The player if it exists, undefined otherwise.
      */
-    create(options: PlayerOptions): Player;
+    getPlayer(guildId: string): Player | undefined;
     /**
+     * @deprecated - Will be removed with v2.10.0 use {@link getPlayer} instead
      * Returns a player or undefined if it does not exist.
      * @param guildId The guild ID of the player to retrieve.
      * @returns The player if it exists, undefined otherwise.
      */
-    get(guildId: string): Player | undefined;
+    get(guildId: string): Promise<Player | undefined>;
+    /**
+     * Creates a player or returns one if it already exists.
+     * @param options The options to create the player with.
+     * @returns The created player.
+     */
+    create(options: PlayerOptions): Player;
     /**
      * Destroys a player.
      * @param guildId The guild ID of the player to destroy.
@@ -997,10 +1062,10 @@ declare class Manager extends EventEmitter {
      */
     loadPlayerStates(nodeId: string): Promise<void>;
     /**
-     * Returns the node to use based on the configured `useNode` and `usePriority` options.
-     * If `usePriority` is true, the node is chosen based on priority, otherwise it is chosen based on the `useNode` option.
+     * Returns the node to use based on the configured `useNode` and `enablePriorityMode` options.
+     * If `enablePriorityMode` is true, the node is chosen based on priority, otherwise it is chosen based on the `useNode` option.
      * If `useNode` is "leastLoad", the node with the lowest load is chosen, if it is "leastPlayers", the node with the fewest players is chosen.
-     * If `usePriority` is false and `useNode` is not set, the node with the lowest load is chosen.
+     * 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;
@@ -1072,7 +1137,7 @@ declare class Manager extends EventEmitter {
      * @param player The Player instance to serialize
      * @returns The serialized Player instance
      */
-    private serializePlayer;
+    serializePlayer(player: Player): Record<string, unknown>;
     /**
      * Checks for players that are no longer active and deletes their saved state files.
      * This is done to prevent stale state files from accumulating on the file system.
@@ -1114,17 +1179,27 @@ interface Payload {
     };
 }
 interface ManagerOptions {
-    /** Whether players should automatically play the next song. */
-    autoPlay?: boolean;
-    /** The search platform autoplay should use. Fallback to YouTube if not found.
-     * Use enum `SearchPlatform`. */
-    autoPlaySearchPlatform?: SearchPlatform;
+    /** The state storage options.
+     *
+     * @default { type: StateStorageType.Collection }
+     */
+    stateStorage?: StateStorageOptions;
+    /** Enable priority mode over least player count or load balancing? */
+    enablePriorityMode?: boolean;
+    /** Automatically play the next track when the current one ends. */
+    playNextOnEnd?: boolean;
+    /** An array of search platforms to use for autoplay. First to last matters
+     * Use enum `AutoPlayPlatform`.
+     */
+    autoPlaySearchPlatforms?: AutoPlayPlatform[];
     /** The client ID to use. */
     clientId?: string;
     /** Value to use for the `Client-Name` header. */
     clientName?: string;
     /** The array of shard IDs connected to this manager instance. */
     clusterId?: number;
+    /** List of plugins to load. */
+    enabledPlugins?: Plugin[];
     /** The default search platform to use.
      * Use enum `SearchPlatform`. */
     defaultSearchPlatform?: SearchPlatform;
@@ -1136,16 +1211,12 @@ interface ManagerOptions {
     maxPreviousTracks?: number;
     /** The array of nodes to connect to. */
     nodes?: NodeOptions[];
-    /** A array of plugins to use. */
-    plugins?: Plugin[];
     /** Whether the YouTube video titles should be replaced if the Author does not exactly match. */
-    replaceYouTubeCredentials?: boolean;
+    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? */
     useNode?: UseNodeOptions.LeastLoad | UseNodeOptions.LeastPlayers;
-    /** Use priority mode over least amount of player or load? */
-    usePriority?: boolean;
     /**
      * Function to send data to the websocket.
      * @param id The ID of the node to send the data to.
@@ -1153,6 +1224,21 @@ interface ManagerOptions {
      */
     send(id: string, payload: Payload): void;
 }
+interface RedisConfig {
+    host: string;
+    port: string;
+    password?: string;
+    db?: number;
+    prefix?: string;
+}
+declare enum StateStorageType {
+    Collection = "collection",
+    Redis = "redis"
+}
+interface StateStorageOptions {
+    type: StateStorageType;
+    redisConfig?: RedisConfig;
+}
 declare enum TrackPartial {
     /** The base64 encoded string of the track */
     Track = "track",
@@ -1202,6 +1288,14 @@ declare enum SearchPlatform {
     YouTube = "ytsearch",
     YouTubeMusic = "ytmsearch"
 }
+declare enum AutoPlayPlatform {
+    Spotify = "spotify",
+    Deezer = "deezer",
+    SoundCloud = "soundcloud",
+    Tidal = "tidal",
+    VKMusic = "vkmusic",
+    YouTube = "youtube"
+}
 declare enum PlayerStateEventTypes {
     AutoPlayChange = "playerAutoplay",
     ConnectionChange = "playerConnection",
@@ -1360,11 +1454,27 @@ interface ManagerEvents {
     [ManagerEventTypes.ChapterStarted]: [player: Player, track: Track, payload: SponsorBlockChapterStarted];
     [ManagerEventTypes.ChaptersLoaded]: [player: Player, track: Track, payload: SponsorBlockChaptersLoaded];
 }
+interface PlayerStore {
+    get(guildId: string): Promise<Player | undefined>;
+    set(guildId: string, player: Player): Promise<void>;
+    delete(guildId: string): Promise<void>;
+    keys(): Promise<string[]>;
+    has(guildId: string): Promise<boolean>;
+    filter(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Map<string, Player>>;
+    find(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Player | undefined>;
+    map<T>(callback: (player: Player, guildId: string) => T | Promise<T>): Promise<T[]>;
+    forEach(callback: (player: Player, guildId: string) => void | Promise<void>): Promise<void>;
+    some(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
+    every(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
+    size(): Promise<number>;
+    clear(): Promise<void>;
+    entries(): AsyncIterableIterator<[string, Player]>;
+}
 
 declare class Player {
     options: PlayerOptions;
     /** The Queue for the Player. */
-    readonly queue: Queue;
+    queue: IQueue;
     /** The filters applied to the audio. */
     filters: Filters;
     /** Whether the queue repeats the track. */
@@ -1402,11 +1512,11 @@ declare class Player {
     /** The autoplay state of the player. */
     isAutoplay: boolean;
     /** The number of times to try autoplay before emitting queueEnd. */
-    autoplayTries: number | null;
+    autoplayTries: number;
     private static _manager;
     private readonly data;
     private dynamicLoopInterval;
-    private dynamicRepeatIntervalMs;
+    dynamicRepeatIntervalMs: number | null;
     /**
      * Creates a new player, returns one if it already exists.
      * @param options The player options.
@@ -1569,7 +1679,7 @@ declare class Player {
      * @throws {TypeError} If the repeat parameter is not a boolean.
      * @throws {RangeError} If the queue size is less than or equal to 1.
      */
-    setDynamicRepeat(repeat: boolean, ms: number): this;
+    setDynamicRepeat(repeat: boolean, ms: number): Promise<this>;
     /**
      * Restarts the currently playing track from the beginning.
      * If there is no track playing, it will play the next track in the queue.
@@ -2136,5 +2246,5 @@ declare class Plugin {
     load(manager: Manager): void;
 }
 
-export { AutoPlayUtils, AvailableFilters, Filters, LoadTypes, Manager, ManagerEventTypes, Node, Player, PlayerStateEventTypes, Plugin, Queue, Rest, SearchPlatform, SeverityTypes, SponsorBlockSegment, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
-export type { CPUStats, EqualizerBand, Exception, Extendable, FrameStats, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerOptions, MemoryStats, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerUpdate, PlaylistData, PlaylistInfoData, PlaylistRawData, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, State, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent };
+export { AutoPlayPlatform, AutoPlayUtils, AvailableFilters, Filters, LoadTypes, Manager, ManagerEventTypes, Node, Player, PlayerStateEventTypes, Plugin, Queue, Rest, SearchPlatform, SeverityTypes, SponsorBlockSegment, StateStorageType, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
+export type { CPUStats, EqualizerBand, Exception, Extendable, FrameStats, IQueue, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerOptions, MemoryStats, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStore, PlayerUpdate, PlaylistData, PlaylistInfoData, PlaylistRawData, RedisConfig, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, State, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent };

package/dist/storage/CollectionPlayerStore.js

@@ -0,0 +1,80 @@
+"use strict";
+// THIS WILL BE REMOVED IF YOU DONT FIND A USE FOR IT.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionPlayerStore = void 0;
+const collection_1 = require("@discordjs/collection");
+const logExecutionTime_1 = require("../utils/logExecutionTime");
+class CollectionPlayerStore {
+    store = new collection_1.Collection();
+    async get(guildId) {
+        return (0, logExecutionTime_1.logExecutionTime)("CollectionStore.get", async () => {
+            return this.store.get(guildId);
+        });
+    }
+    async set(guildId, player) {
+        this.store.set(guildId, player);
+    }
+    async delete(guildId) {
+        this.store.delete(guildId);
+    }
+    async keys() {
+        return [...this.store.keys()];
+    }
+    async has(guildId) {
+        return this.store.has(guildId);
+    }
+    async filter(predicate) {
+        const result = new Map();
+        for (const [guildId, player] of this.store.entries()) {
+            if (await predicate(player, guildId)) {
+                result.set(guildId, player);
+            }
+        }
+        return result;
+    }
+    async find(predicate) {
+        for (const [guildId, player] of this.store.entries()) {
+            if (await predicate(player, guildId))
+                return player;
+        }
+        return undefined;
+    }
+    async map(callback) {
+        const results = [];
+        for (const [guildId, player] of this.store.entries()) {
+            results.push(await callback(player, guildId));
+        }
+        return results;
+    }
+    async forEach(callback) {
+        for (const [guildId, player] of this.store.entries()) {
+            await callback(player, guildId);
+        }
+    }
+    async some(predicate) {
+        for (const [guildId, player] of this.store.entries()) {
+            if (await predicate(player, guildId))
+                return true;
+        }
+        return false;
+    }
+    async every(predicate) {
+        for (const [guildId, player] of this.store.entries()) {
+            if (!(await predicate(player, guildId)))
+                return false;
+        }
+        return true;
+    }
+    async size() {
+        return this.store.size;
+    }
+    async clear() {
+        this.store.clear();
+    }
+    async *entries() {
+        for (const entry of this.store.entries()) {
+            yield entry;
+        }
+    }
+}
+exports.CollectionPlayerStore = CollectionPlayerStore;

package/dist/storage/RedisPlayerStore.js

@@ -0,0 +1,159 @@
+"use strict";
+// THIS WILL BE REMOVED IF YOU DONT FIND A USE FOR IT.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisPlayerStore = void 0;
+const logExecutionTime_1 = require("../utils/logExecutionTime");
+class RedisPlayerStore {
+    redis;
+    manager;
+    prefix;
+    constructor(redis, manager, prefix = "magmastream:") {
+        this.redis = redis;
+        this.manager = manager;
+        this.prefix = prefix;
+    }
+    getKey(guildId) {
+        return `${this.prefix}player:${guildId}`;
+    }
+    async get(guildId) {
+        return (0, logExecutionTime_1.logExecutionTime)("RedisStore.get", async () => {
+            const raw = await this.redis.get(this.getKey(guildId));
+            if (!raw)
+                return undefined;
+            return JSON.parse(raw);
+        });
+    }
+    async set(guildId, player) {
+        const serialized = this.manager.serializePlayer(player);
+        await this.redis.set(this.getKey(guildId), JSON.stringify(serialized));
+    }
+    async delete(guildId) {
+        await this.redis.del(this.getKey(guildId));
+    }
+    async keys() {
+        const keys = await this.redis.keys(`${this.prefix}player:*`);
+        return keys.map((key) => key.replace(`${this.prefix}player:`, ""));
+    }
+    async has(guildId) {
+        return (await this.redis.exists(this.getKey(guildId))) === 1;
+    }
+    async filter(predicate) {
+        const keys = await this.keys();
+        const pipeline = this.redis.pipeline();
+        for (const guildId of keys) {
+            pipeline.get(this.getKey(guildId));
+        }
+        const results = await pipeline.exec();
+        const result = new Map();
+        for (let i = 0; i < results.length; i++) {
+            const [err, raw] = results[i];
+            if (err || typeof raw !== "string")
+                continue;
+            const guildId = keys[i];
+            const player = JSON.parse(raw);
+            if (await predicate(player, guildId)) {
+                result.set(guildId, player);
+            }
+        }
+        return result;
+    }
+    async find(predicate) {
+        for (const guildId of await this.keys()) {
+            const raw = await this.redis.get(this.getKey(guildId));
+            if (!raw)
+                continue;
+            const parsed = JSON.parse(raw);
+            if (await predicate(parsed, guildId))
+                return parsed;
+        }
+        return undefined;
+    }
+    async map(callback) {
+        const keys = await this.keys();
+        if (!keys.length)
+            return [];
+        const pipeline = this.redis.pipeline();
+        for (const guildId of keys) {
+            pipeline.get(this.getKey(guildId));
+        }
+        const results = await pipeline.exec();
+        const output = [];
+        for (let i = 0; i < results.length; i++) {
+            const [err, raw] = results[i];
+            if (err || typeof raw !== "string")
+                continue;
+            const guildId = keys[i];
+            const player = JSON.parse(raw);
+            output.push(await callback(player, guildId));
+        }
+        return output;
+    }
+    async forEach(callback) {
+        for (const guildId of await this.keys()) {
+            const raw = await this.redis.get(this.getKey(guildId));
+            if (!raw)
+                continue;
+            const parsed = JSON.parse(raw);
+            await callback(parsed, guildId);
+        }
+    }
+    async some(predicate) {
+        const keys = await this.keys();
+        if (!keys.length)
+            return false;
+        const pipeline = this.redis.pipeline();
+        for (const guildId of keys) {
+            pipeline.get(this.getKey(guildId));
+        }
+        const results = await pipeline.exec();
+        for (let i = 0; i < results.length; i++) {
+            const [err, raw] = results[i];
+            if (err || typeof raw !== "string")
+                continue;
+            const guildId = keys[i];
+            const player = JSON.parse(raw);
+            if (await predicate(player, guildId))
+                return true;
+        }
+        return false;
+    }
+    async every(predicate) {
+        const keys = await this.keys();
+        if (!keys.length)
+            return true;
+        const pipeline = this.redis.pipeline();
+        for (const guildId of keys) {
+            pipeline.get(this.getKey(guildId));
+        }
+        const results = await pipeline.exec();
+        for (let i = 0; i < results.length; i++) {
+            const [err, raw] = results[i];
+            if (err || typeof raw !== "string")
+                continue;
+            const guildId = keys[i];
+            const player = JSON.parse(raw);
+            if (!(await predicate(player, guildId)))
+                return false;
+        }
+        return true;
+    }
+    async size() {
+        const keys = await this.keys();
+        return keys.length;
+    }
+    async clear() {
+        const keys = await this.redis.keys(`${this.prefix}player:*`);
+        if (keys.length) {
+            await this.redis.del(...keys);
+        }
+    }
+    async *entries() {
+        for (const guildId of await this.keys()) {
+            const raw = await this.redis.get(this.getKey(guildId));
+            if (!raw)
+                continue;
+            yield [guildId, JSON.parse(raw)];
+        }
+    }
+}
+exports.RedisPlayerStore = RedisPlayerStore;