magmastream 2.9.0-dev.2 → 2.9.0-dev.20

package/README.md

@@ -95,12 +95,12 @@
 | [Stal](https://discord.com/oauth2/authorize?client_id=923938180263182356&scope=bot%20applications.commands&permissions=27648861246)                                                                                                                   | memte         |
 | [Lunio](https://discord.com/api/oauth2/authorize?client_id=945030475779551415&permissions=61991952&scope=bot+applications.commands)                                                                                                                   | vexi          |
 | [JukeDisc](https://discord.com/oauth2/authorize?client_id=1109751797549105176&permissions=968552214080&scope=bot+applications.commands)                                                                                                               | Theo          |
-| [Cool Music](https://discord.com/oauth2/authorize?client_id=923529398425096193&permissions=12888394808&redirect_uri=https%3A%2F%2Fdiscord.gg%2Fcool-music-support-925619107460698202&response_type=code&scope=bot%20identify%20applications.commands) | Itz Random    |
+| [Leo](https://discord.com/oauth2/authorize?client_id=923529398425096193&permissions=12888394808&scope=bot%20identify%20applications.commands) | Itz Random    |
 | [Soundy](https://dsc.gg/sndy)                                                                                                                                                                                                                         | iaMJ          |
 | [HamBot](https://discord.com/oauth2/authorize?client_id=1049314312776335390)                                                                                                                                                                          | yanishamburger|
 | [Miyu](https://discord.com/oauth2/authorize?client_id=1277180179273482280&permissions=572851999731703&response_type=code&redirect_uri=https%3A%2F%2Fdiscord.gg%2Ftn3nbFB8nX&integration_type=0&scope=identify+applications.commands+bot)              | Kenver        |
 | [Savage Bot](https://discord.com/oauth2/authorize?client_id=823703707522433054&permissions=8&scope=bot%20applications.commands)                                                                                                                       | Savage   
-| [rive](https://discord.com/oauth2/authorize?client_id=1350601402325405806)                                                                                                                                                                            | pomice                                                                                                                                                                      
+| [lost](https://discord.com/oauth2/authorize?client_id=1280681209604739204)                                                                                                                                                                            | pomice                                                                                                                                                                      
 
 
 Want to showcase your bot? Feel free to create a pull request and add it to our growing list of amazing bots powered by Magmastream!

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 {
@@ -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,35 @@ 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>;
+    setPrevious(tracks: 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 +625,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 +695,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 +915,33 @@ 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>;
+    setPrevious(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,13 +954,14 @@ 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.enabledPlugins - An array of enabledPlugins to load.
      * @param options.nodes - An array of node options to create nodes from.
      * @param options.playNextOnEnd - 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.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.
@@ -926,17 +986,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.
@@ -990,6 +1057,12 @@ declare class Manager extends EventEmitter {
      * @param {string} guildId - The guild ID of the player to save
      */
     savePlayerState(guildId: string): Promise<void>;
+    /**
+     * Sleeps for a specified amount of time.
+     * @param ms The amount of time to sleep in milliseconds.
+     * @returns A promise that resolves after the specified amount of time.
+     */
+    private sleep;
     /**
      * Loads player states from the JSON file.
      * @param nodeId The ID of the node to load player states from.
@@ -1072,7 +1145,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,13 +1187,19 @@ interface Payload {
     };
 }
 interface ManagerOptions {
+    /** 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;
-    /** The search platform autoplay should use
-     * Use enum `SearchPlatform`. */
-    autoPlaySearchPlatform?: SearchPlatform;
+    /** 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. */
@@ -1135,7 +1214,7 @@ interface ManagerOptions {
     /** 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;
+    lastFmApiKey?: string;
     /** The maximum number of previous tracks to store. */
     maxPreviousTracks?: number;
     /** The array of nodes to connect to. */
@@ -1153,6 +1232,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",
@@ -1195,6 +1289,7 @@ declare enum SearchPlatform {
     Bandcamp = "bcsearch",
     Deezer = "dzsearch",
     Jiosaavn = "jssearch",
+    Qobuz = "qbsearch",
     SoundCloud = "scsearch",
     Spotify = "spsearch",
     Tidal = "tdsearch",
@@ -1202,6 +1297,15 @@ declare enum SearchPlatform {
     YouTube = "ytsearch",
     YouTubeMusic = "ytmsearch"
 }
+declare enum AutoPlayPlatform {
+    Spotify = "spotify",
+    Deezer = "deezer",
+    SoundCloud = "soundcloud",
+    Tidal = "tidal",
+    VKMusic = "vkmusic",
+    Qobuz = "qobuz",
+    YouTube = "youtube"
+}
 declare enum PlayerStateEventTypes {
     AutoPlayChange = "playerAutoplay",
     ConnectionChange = "playerConnection",
@@ -1360,11 +1464,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 +1522,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 +1689,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 +2256,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,77 @@
+"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");
+class CollectionPlayerStore {
+    store = new collection_1.Collection();
+    async get(guildId) {
+        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,156 @@
+"use strict";
+// THIS WILL BE REMOVED IF YOU DONT FIND A USE FOR IT.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisPlayerStore = void 0;
+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) {
+        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;