magmastream 2.9.0-dev.4 → 2.9.0-dev.40

package/dist/statestorage/RedisQueue.js

@@ -0,0 +1,427 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisQueue = void 0;
+const Enums_1 = require("../structures/Enums");
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+class RedisQueue {
+    guildId;
+    manager;
+    /**
+     * The Redis instance.
+     */
+    redis;
+    /**
+     * The prefix for the Redis keys.
+     */
+    redisPrefix;
+    /**
+     * Constructs a new RedisQueue.
+     * @param guildId The guild ID.
+     * @param manager The Manager instance.
+     */
+    constructor(guildId, manager) {
+        this.guildId = guildId;
+        this.manager = manager;
+        this.redis = manager.redis;
+        this.redisPrefix = manager.options.stateStorage.redisConfig.prefix?.endsWith(":")
+            ? manager.options.stateStorage.redisConfig.prefix
+            : `${manager.options.stateStorage.redisConfig.prefix ?? "magmastream"}:`;
+    }
+    /**
+     * @returns The queue key.
+     */
+    get queueKey() {
+        return `${this.redisPrefix}queue:${this.guildId}:tracks`;
+    }
+    /**
+     * @returns The current key.
+     */
+    get currentKey() {
+        return `${this.redisPrefix}queue:${this.guildId}:current`;
+    }
+    /**
+     * @returns The previous key.
+     */
+    get previousKey() {
+        return `${this.redisPrefix}queue:${this.guildId}:previous`;
+    }
+    /**
+     * Helper to serialize/deserialize Track
+     */
+    serialize(track) {
+        return JSON.stringify(track);
+    }
+    /**
+     * Helper to serialize/deserialize Track
+     */
+    deserialize(data) {
+        return JSON.parse(data);
+    }
+    /**
+     * @returns The current track.
+     */
+    async getCurrent() {
+        const raw = await this.redis.get(this.currentKey);
+        return raw ? this.deserialize(raw) : null;
+    }
+    /**
+     * @param track The track to set.
+     */
+    async setCurrent(track) {
+        if (track) {
+            await this.redis.set(this.currentKey, this.serialize(track));
+        }
+        else {
+            await this.redis.del(this.currentKey);
+        }
+    }
+    /**
+     * @returns The previous tracks.
+     */
+    async getPrevious() {
+        const raw = await this.redis.lrange(this.previousKey, 0, -1);
+        return raw.map(this.deserialize);
+    }
+    /**
+     * @param track The track to add.
+     */
+    async addPrevious(track) {
+        const tracks = Array.isArray(track) ? track : [track];
+        if (!tracks.length)
+            return;
+        const serialized = tracks.map(this.serialize);
+        if (!serialized.length)
+            return;
+        await this.redis.lpush(this.previousKey, ...serialized.reverse());
+    }
+    /**
+     * @param track The track to set.
+     */
+    async setPrevious(track) {
+        const tracks = Array.isArray(track) ? track : [track];
+        if (!tracks.length)
+            return;
+        await this.redis.del(this.previousKey);
+        await this.redis.rpush(this.previousKey, ...tracks.map(this.serialize));
+    }
+    /**
+     * @returns The newest track.
+     */
+    async popPrevious() {
+        const raw = await this.redis.lpop(this.previousKey); // get newest track (index 0)
+        return raw ? this.deserialize(raw) : null;
+    }
+    /**
+     * Clears the previous tracks.
+     */
+    async clearPrevious() {
+        await this.redis.del(this.previousKey);
+    }
+    /**
+     * @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.
+     */
+    async add(track, offset) {
+        const isArray = Array.isArray(track);
+        const tracks = isArray ? track : [track];
+        const serialized = tracks.map((t) => this.serialize(t));
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        // If there's no current track, pop one from the list
+        if (!(await this.getCurrent())) {
+            const current = serialized.shift();
+            if (current) {
+                await this.setCurrent(this.deserialize(current));
+            }
+        }
+        if (typeof offset === "number" && !isNaN(offset)) {
+            const queue = await this.redis.lrange(this.queueKey, 0, -1);
+            queue.splice(offset, 0, ...serialized);
+            await this.redis.del(this.queueKey);
+            if (queue.length > 0) {
+                await this.redis.rpush(this.queueKey, ...queue);
+            }
+        }
+        else if (serialized.length > 0) {
+            await this.redis.rpush(this.queueKey, ...serialized);
+        }
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Added ${tracks.length} track(s) to queue`);
+        if (this.manager.players.has(this.guildId) && this.manager.players.get(this.guildId).isAutoplay) {
+            if (!Array.isArray(track)) {
+                const botUser = (await this.manager.players.get(this.guildId).get("Internal_BotUser"));
+                if (botUser && botUser.id === track.requester.id) {
+                    this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+                        changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+                        details: {
+                            type: "queue",
+                            action: "autoPlayAdd",
+                            tracks: Array.isArray(track) ? track : [track],
+                        },
+                    });
+                    return;
+                }
+            }
+        }
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "add",
+                tracks,
+            },
+        });
+    }
+    async remove(startOrPos = 0, end) {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const queue = await this.redis.lrange(this.queueKey, 0, -1);
+        let removed = [];
+        if (typeof end === "number") {
+            if (startOrPos >= end || startOrPos >= queue.length) {
+                throw new RangeError("Invalid range.");
+            }
+            removed = queue.slice(startOrPos, end);
+            queue.splice(startOrPos, end - startOrPos);
+        }
+        else {
+            removed = queue.splice(startOrPos, 1);
+        }
+        await this.redis.del(this.queueKey);
+        if (queue.length > 0) {
+            await this.redis.rpush(this.queueKey, ...queue);
+        }
+        const deserialized = removed.map(this.deserialize);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Removed ${removed.length} track(s) from position ${startOrPos}${end ? ` to ${end}` : ""}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "remove",
+                tracks: deserialized,
+            },
+        });
+        return deserialized;
+    }
+    /**
+     * Clears the queue.
+     */
+    async clear() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        await this.redis.del(this.queueKey);
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "clear",
+                tracks: [],
+            },
+        });
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Cleared the queue for: ${this.guildId}`);
+    }
+    /**
+     * @returns The size of the queue.
+     */
+    async size() {
+        return await this.redis.llen(this.queueKey);
+    }
+    /**
+     * @returns The total size of tracks in the queue including the current track.
+     */
+    async totalSize() {
+        const size = await this.size();
+        return (await this.getCurrent()) ? size + 1 : size;
+    }
+    /**
+     * @returns The total duration of the queue in milliseconds.
+     * This includes the duration of the currently playing track.
+     */
+    async duration() {
+        const tracks = await this.redis.lrange(this.queueKey, 0, -1);
+        const currentDuration = (await this.getCurrent())?.duration || 0;
+        const total = tracks.reduce((acc, raw) => {
+            try {
+                const parsed = this.deserialize(raw);
+                return acc + (parsed.duration || 0);
+            }
+            catch {
+                return acc;
+            }
+        }, currentDuration);
+        return total;
+    }
+    /**
+     * Shuffles the queue.
+     */
+    async shuffle() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const queue = await this.redis.lrange(this.queueKey, 0, -1);
+        for (let i = queue.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [queue[i], queue[j]] = [queue[j], queue[i]];
+        }
+        await this.redis.del(this.queueKey);
+        if (queue.length > 0) {
+            await this.redis.rpush(this.queueKey, ...queue);
+        }
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "shuffle",
+            },
+        });
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] Shuffled the queue for: ${this.guildId}`);
+    }
+    /**
+     * Shuffles the queue, but keeps the tracks of the same user together.
+     */
+    async userBlockShuffle() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const rawTracks = await this.redis.lrange(this.queueKey, 0, -1);
+        const deserialized = rawTracks.map(this.deserialize);
+        const userMap = new Map();
+        for (const track of deserialized) {
+            const userId = track.requester.id;
+            if (!userMap.has(userId))
+                userMap.set(userId, []);
+            userMap.get(userId).push(track);
+        }
+        const shuffledQueue = [];
+        while (shuffledQueue.length < deserialized.length) {
+            for (const [, tracks] of userMap) {
+                const track = tracks.shift();
+                if (track)
+                    shuffledQueue.push(track);
+            }
+        }
+        await this.redis.del(this.queueKey);
+        await this.redis.rpush(this.queueKey, ...shuffledQueue.map(this.serialize));
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "userBlock",
+            },
+        });
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] userBlockShuffled the queue for: ${this.guildId}`);
+    }
+    /**
+     * Shuffles the queue round-robin style.
+     */
+    async roundRobinShuffle() {
+        const oldPlayer = this.manager.players.get(this.guildId) ? { ...this.manager.players.get(this.guildId) } : null;
+        const rawTracks = await this.redis.lrange(this.queueKey, 0, -1);
+        const deserialized = rawTracks.map(this.deserialize);
+        const userMap = new Map();
+        for (const track of deserialized) {
+            const userId = track.requester.id;
+            if (!userMap.has(userId))
+                userMap.set(userId, []);
+            userMap.get(userId).push(track);
+        }
+        // Shuffle each user's tracks
+        for (const tracks of userMap.values()) {
+            for (let i = tracks.length - 1; i > 0; i--) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [tracks[i], tracks[j]] = [tracks[j], tracks[i]];
+            }
+        }
+        const users = [...userMap.keys()];
+        const queues = users.map((id) => userMap.get(id));
+        const shuffledQueue = [];
+        while (queues.some((q) => q.length > 0)) {
+            for (const q of queues) {
+                const track = q.shift();
+                if (track)
+                    shuffledQueue.push(track);
+            }
+        }
+        await this.redis.del(this.queueKey);
+        await this.redis.rpush(this.queueKey, ...shuffledQueue.map(this.serialize));
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this.manager.players.get(this.guildId), {
+            changeType: Enums_1.PlayerStateEventTypes.QueueChange,
+            details: {
+                type: "queue",
+                action: "roundRobin",
+            },
+        });
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[QUEUE] roundRobinShuffled the queue for: ${this.guildId}`);
+    }
+    /**
+     * Removes the first track from the queue.
+     */
+    async dequeue() {
+        const raw = await this.redis.lpop(this.queueKey);
+        return raw ? this.deserialize(raw) : undefined;
+    }
+    /**
+     * Adds a track to the front of the queue.
+     */
+    async enqueueFront(track) {
+        const serialized = Array.isArray(track) ? track.map(this.serialize) : [this.serialize(track)];
+        // Redis: LPUSH adds to front, reverse to maintain order if multiple tracks
+        await this.redis.lpush(this.queueKey, ...serialized.reverse());
+    }
+    /**
+     * @returns The tracks in the queue.
+     */
+    async getTracks() {
+        const raw = await this.redis.lrange(this.queueKey, 0, -1);
+        return raw.map(this.deserialize);
+    }
+    /**
+     * @returns The tracks in the queue from the start to the end.
+     */
+    async getSlice(start = 0, end = -1) {
+        const raw = await this.redis.lrange(this.queueKey, start, end === -1 ? -1 : end - 1);
+        return raw.map(this.deserialize);
+    }
+    /**
+     * Modifies the queue at the specified index.
+     */
+    async modifyAt(start, deleteCount = 0, ...items) {
+        const queue = await this.redis.lrange(this.queueKey, 0, -1);
+        const removed = queue.splice(start, deleteCount, ...items.map(this.serialize));
+        await this.redis.del(this.queueKey);
+        if (queue.length > 0) {
+            await this.redis.rpush(this.queueKey, ...queue);
+        }
+        return removed.map(this.deserialize);
+    }
+    /**
+     * @returns The tracks in the queue after the specified index.
+     */
+    async mapAsync(callback) {
+        const tracks = await this.getTracks(); // same as lrange + deserialize
+        return tracks.map(callback);
+    }
+    /**
+     * @returns The tracks in the queue that match the specified condition.
+     */
+    async filterAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.filter(callback);
+    }
+    /**
+     * @returns The first track in the queue that matches the specified condition.
+     */
+    async findAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.find(callback);
+    }
+    /**
+     * @returns Whether any tracks in the queue match the specified condition.
+     */
+    async someAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.some(callback);
+    }
+    /**
+     * @returns Whether all tracks in the queue match the specified condition.
+     */
+    async everyAsync(callback) {
+        const tracks = await this.getTracks();
+        return tracks.every(callback);
+    }
+}
+exports.RedisQueue = RedisQueue;

package/dist/structures/Enums.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailableFilters = exports.SponsorBlockSegment = exports.SeverityTypes = exports.TrackEndReasonTypes = exports.ManagerEventTypes = exports.TrackPartial = exports.UseNodeOptions = exports.TrackSourceTypes = exports.PlayerStateEventTypes = exports.SearchPlatform = exports.LoadTypes = exports.StateTypes = exports.AutoPlayPlatform = exports.StateStorageType = void 0;
+/**
+ * State Storage Enum
+ */
+var StateStorageType;
+(function (StateStorageType) {
+    StateStorageType["Memory"] = "memory";
+    StateStorageType["Redis"] = "redis";
+    StateStorageType["JSON"] = "json";
+})(StateStorageType || (exports.StateStorageType = StateStorageType = {}));
+/**
+ * AutoPlay Platform Enum
+ */
+var AutoPlayPlatform;
+(function (AutoPlayPlatform) {
+    AutoPlayPlatform["Spotify"] = "spotify";
+    AutoPlayPlatform["Deezer"] = "deezer";
+    AutoPlayPlatform["SoundCloud"] = "soundcloud";
+    AutoPlayPlatform["Tidal"] = "tidal";
+    AutoPlayPlatform["VKMusic"] = "vkmusic";
+    AutoPlayPlatform["Qobuz"] = "qobuz";
+    AutoPlayPlatform["YouTube"] = "youtube";
+})(AutoPlayPlatform || (exports.AutoPlayPlatform = AutoPlayPlatform = {}));
+/**
+ * State Types Enum
+ */
+var StateTypes;
+(function (StateTypes) {
+    StateTypes["Connected"] = "CONNECTED";
+    StateTypes["Connecting"] = "CONNECTING";
+    StateTypes["Disconnected"] = "DISCONNECTED";
+    StateTypes["Disconnecting"] = "DISCONNECTING";
+    StateTypes["Destroying"] = "DESTROYING";
+})(StateTypes || (exports.StateTypes = StateTypes = {}));
+/**
+ * Load Types Enum
+ */
+var LoadTypes;
+(function (LoadTypes) {
+    LoadTypes["Track"] = "track";
+    LoadTypes["Playlist"] = "playlist";
+    LoadTypes["Search"] = "search";
+    LoadTypes["Empty"] = "empty";
+    LoadTypes["Error"] = "error";
+    /** Nodelink */
+    LoadTypes["Album"] = "album";
+    /** Nodelink */
+    LoadTypes["Artist"] = "artist";
+    /** Nodelink */
+    LoadTypes["Station"] = "station";
+    /** Nodelink */
+    LoadTypes["Podcast"] = "podcast";
+    /** Nodelink */
+    LoadTypes["Show"] = "show";
+    /** Nodelink */
+    LoadTypes["Short"] = "short";
+})(LoadTypes || (exports.LoadTypes = LoadTypes = {}));
+/**
+ * Search Platform Enum
+ */
+var SearchPlatform;
+(function (SearchPlatform) {
+    SearchPlatform["AppleMusic"] = "amsearch";
+    SearchPlatform["Bandcamp"] = "bcsearch";
+    SearchPlatform["Deezer"] = "dzsearch";
+    SearchPlatform["Jiosaavn"] = "jssearch";
+    SearchPlatform["Qobuz"] = "qbsearch";
+    SearchPlatform["SoundCloud"] = "scsearch";
+    SearchPlatform["Spotify"] = "spsearch";
+    SearchPlatform["Tidal"] = "tdsearch";
+    SearchPlatform["VKMusic"] = "vksearch";
+    SearchPlatform["YouTube"] = "ytsearch";
+    SearchPlatform["YouTubeMusic"] = "ytmsearch";
+})(SearchPlatform || (exports.SearchPlatform = SearchPlatform = {}));
+/**
+ * Player State Event Types Enum
+ */
+var PlayerStateEventTypes;
+(function (PlayerStateEventTypes) {
+    PlayerStateEventTypes["AutoPlayChange"] = "playerAutoplay";
+    PlayerStateEventTypes["ConnectionChange"] = "playerConnection";
+    PlayerStateEventTypes["RepeatChange"] = "playerRepeat";
+    PlayerStateEventTypes["PauseChange"] = "playerPause";
+    PlayerStateEventTypes["QueueChange"] = "queueChange";
+    PlayerStateEventTypes["TrackChange"] = "trackChange";
+    PlayerStateEventTypes["VolumeChange"] = "volumeChange";
+    PlayerStateEventTypes["ChannelChange"] = "channelChange";
+    PlayerStateEventTypes["PlayerCreate"] = "playerCreate";
+    PlayerStateEventTypes["PlayerDestroy"] = "playerDestroy";
+})(PlayerStateEventTypes || (exports.PlayerStateEventTypes = PlayerStateEventTypes = {}));
+/**
+ * Track Source Types Enum
+ */
+var TrackSourceTypes;
+(function (TrackSourceTypes) {
+    TrackSourceTypes["AppleMusic"] = "applemusic";
+    TrackSourceTypes["Bandcamp"] = "bandcamp";
+    TrackSourceTypes["Deezer"] = "deezer";
+    TrackSourceTypes["Jiosaavn"] = "jiosaavn";
+    TrackSourceTypes["Qobuz"] = "qobuz";
+    TrackSourceTypes["SoundCloud"] = "soundcloud";
+    TrackSourceTypes["Spotify"] = "spotify";
+    TrackSourceTypes["Tidal"] = "tidal";
+    TrackSourceTypes["VKMusic"] = "vkmusic";
+    TrackSourceTypes["YouTube"] = "youtube";
+})(TrackSourceTypes || (exports.TrackSourceTypes = TrackSourceTypes = {}));
+/**
+ * Use Node Options Enum
+ */
+var UseNodeOptions;
+(function (UseNodeOptions) {
+    UseNodeOptions["LeastLoad"] = "leastLoad";
+    UseNodeOptions["LeastPlayers"] = "leastPlayers";
+})(UseNodeOptions || (exports.UseNodeOptions = UseNodeOptions = {}));
+/**
+ * Track Partial Enum
+ */
+var TrackPartial;
+(function (TrackPartial) {
+    /** The base64 encoded string of the track */
+    TrackPartial["Track"] = "track";
+    /** The title of the track */
+    TrackPartial["Title"] = "title";
+    /** The track identifier */
+    TrackPartial["Identifier"] = "identifier";
+    /** The author of the track */
+    TrackPartial["Author"] = "author";
+    /** The length of the track in milliseconds */
+    TrackPartial["Duration"] = "duration";
+    /** The ISRC of the track */
+    TrackPartial["Isrc"] = "isrc";
+    /** Whether the track is seekable */
+    TrackPartial["IsSeekable"] = "isSeekable";
+    /** Whether the track is a stream */
+    TrackPartial["IsStream"] = "isStream";
+    /** The URI of the track */
+    TrackPartial["Uri"] = "uri";
+    /** The artwork URL of the track */
+    TrackPartial["ArtworkUrl"] = "artworkUrl";
+    /** The source name of the track */
+    TrackPartial["SourceName"] = "sourceName";
+    /** The thumbnail of the track */
+    TrackPartial["ThumbNail"] = "thumbnail";
+    /** The requester of the track */
+    TrackPartial["Requester"] = "requester";
+    /** The plugin info of the track */
+    TrackPartial["PluginInfo"] = "pluginInfo";
+    /** The custom data of the track */
+    TrackPartial["CustomData"] = "customData";
+})(TrackPartial || (exports.TrackPartial = TrackPartial = {}));
+var ManagerEventTypes;
+(function (ManagerEventTypes) {
+    ManagerEventTypes["ChapterStarted"] = "chapterStarted";
+    ManagerEventTypes["ChaptersLoaded"] = "chaptersLoaded";
+    ManagerEventTypes["Debug"] = "debug";
+    ManagerEventTypes["LyricsFound"] = "lyricsFound";
+    ManagerEventTypes["LyricsLine"] = "lyricsLine";
+    ManagerEventTypes["LyricsNotFound"] = "lyricsNotFound";
+    ManagerEventTypes["NodeConnect"] = "nodeConnect";
+    ManagerEventTypes["NodeCreate"] = "nodeCreate";
+    ManagerEventTypes["NodeDestroy"] = "nodeDestroy";
+    ManagerEventTypes["NodeDisconnect"] = "nodeDisconnect";
+    ManagerEventTypes["NodeError"] = "nodeError";
+    ManagerEventTypes["NodeRaw"] = "nodeRaw";
+    ManagerEventTypes["NodeReconnect"] = "nodeReconnect";
+    ManagerEventTypes["PlayerCreate"] = "playerCreate";
+    ManagerEventTypes["PlayerDestroy"] = "playerDestroy";
+    ManagerEventTypes["PlayerDisconnect"] = "playerDisconnect";
+    ManagerEventTypes["PlayerMove"] = "playerMove";
+    ManagerEventTypes["PlayerRestored"] = "playerRestored";
+    ManagerEventTypes["PlayerStateUpdate"] = "playerStateUpdate";
+    ManagerEventTypes["QueueEnd"] = "queueEnd";
+    ManagerEventTypes["RestoreComplete"] = "restoreComplete";
+    ManagerEventTypes["SegmentSkipped"] = "segmentSkipped";
+    ManagerEventTypes["SegmentsLoaded"] = "segmentsLoaded";
+    ManagerEventTypes["SocketClosed"] = "socketClosed";
+    ManagerEventTypes["TrackEnd"] = "trackEnd";
+    ManagerEventTypes["TrackError"] = "trackError";
+    ManagerEventTypes["TrackStart"] = "trackStart";
+    ManagerEventTypes["TrackStuck"] = "trackStuck";
+    /** Nodelink */
+    ManagerEventTypes["VoiceReceiverDisconnect"] = "voiceReceiverDisconnect";
+    /** Nodelink */
+    ManagerEventTypes["VoiceReceiverConnect"] = "voiceReceiverConnect";
+    /** Nodelink */
+    ManagerEventTypes["VoiceReceiverError"] = "voiceReceiverError";
+    /** Nodelink */
+    ManagerEventTypes["VoiceReceiverStartSpeaking"] = "voiceReceiverStartSpeaking";
+    /** Nodelink */
+    ManagerEventTypes["VoiceReceiverEndSpeaking"] = "voiceReceiverEndSpeaking";
+})(ManagerEventTypes || (exports.ManagerEventTypes = ManagerEventTypes = {}));
+/**
+ * Track End Reason Enum
+ */
+var TrackEndReasonTypes;
+(function (TrackEndReasonTypes) {
+    TrackEndReasonTypes["Finished"] = "finished";
+    TrackEndReasonTypes["LoadFailed"] = "loadFailed";
+    TrackEndReasonTypes["Stopped"] = "stopped";
+    TrackEndReasonTypes["Replaced"] = "replaced";
+    TrackEndReasonTypes["Cleanup"] = "cleanup";
+})(TrackEndReasonTypes || (exports.TrackEndReasonTypes = TrackEndReasonTypes = {}));
+/**
+ * Severity Types Enum
+ */
+var SeverityTypes;
+(function (SeverityTypes) {
+    SeverityTypes["Common"] = "common";
+    SeverityTypes["Suspicious"] = "suspicious";
+    SeverityTypes["Fault"] = "fault";
+})(SeverityTypes || (exports.SeverityTypes = SeverityTypes = {}));
+/**
+ * SponsorBlock Segment Enum
+ */
+var SponsorBlockSegment;
+(function (SponsorBlockSegment) {
+    SponsorBlockSegment["Filler"] = "filler";
+    SponsorBlockSegment["Interaction"] = "interaction";
+    SponsorBlockSegment["Intro"] = "intro";
+    SponsorBlockSegment["MusicOfftopic"] = "music_offtopic";
+    SponsorBlockSegment["Outro"] = "outro";
+    SponsorBlockSegment["Preview"] = "preview";
+    SponsorBlockSegment["SelfPromo"] = "selfpromo";
+    SponsorBlockSegment["Sponsor"] = "sponsor";
+})(SponsorBlockSegment || (exports.SponsorBlockSegment = SponsorBlockSegment = {}));
+/**
+ * Available Filters Enum
+ */
+var AvailableFilters;
+(function (AvailableFilters) {
+    AvailableFilters["BassBoost"] = "bassboost";
+    AvailableFilters["China"] = "china";
+    AvailableFilters["Chipmunk"] = "chipmunk";
+    AvailableFilters["Darthvader"] = "darthvader";
+    AvailableFilters["Daycore"] = "daycore";
+    AvailableFilters["Demon"] = "demon";
+    AvailableFilters["Distort"] = "distort";
+    AvailableFilters["Doubletime"] = "doubletime";
+    AvailableFilters["Earrape"] = "earrape";
+    AvailableFilters["EightD"] = "eightD";
+    AvailableFilters["Electronic"] = "electronic";
+    AvailableFilters["Nightcore"] = "nightcore";
+    AvailableFilters["Party"] = "party";
+    AvailableFilters["Pop"] = "pop";
+    AvailableFilters["Radio"] = "radio";
+    AvailableFilters["SetDistortion"] = "setDistortion";
+    AvailableFilters["SetKaraoke"] = "setKaraoke";
+    AvailableFilters["SetRotation"] = "setRotation";
+    AvailableFilters["SetTimescale"] = "setTimescale";
+    AvailableFilters["Slowmo"] = "slowmo";
+    AvailableFilters["Soft"] = "soft";
+    AvailableFilters["TrebleBass"] = "trebleBass";
+    AvailableFilters["Tremolo"] = "tremolo";
+    AvailableFilters["TV"] = "tv";
+    AvailableFilters["Vaporwave"] = "vaporwave";
+    AvailableFilters["Vibrato"] = "vibrato";
+})(AvailableFilters || (exports.AvailableFilters = AvailableFilters = {}));