magmastream 2.9.3-dev.3 → 2.9.3-dev.30

package/dist/structures/Utils.d.ts

@@ -0,0 +1,169 @@
+import { AutoPlayPlatform, TrackPartial } from "./Enums";
+import { Manager } from "./Manager";
+import { AnyUser, ErrorOrEmptySearchResult, Extendable, LavalinkResponse, SearchResult, SerializedPlayerState, Track, TrackData } from "./Types";
+import { Player } from "./Player";
+export declare abstract class TrackUtils {
+    static trackPartial: TrackPartial[] | null;
+    private static manager;
+    /**
+     * Initializes the TrackUtils class with the given manager.
+     * @param manager The manager instance to use.
+     * @hidden
+     */
+    static init(manager: Manager): void;
+    /**
+     * Sets the partial properties for the Track class. If a Track has some of its properties removed by the partial,
+     * it will be considered a partial Track.
+     * @param {TrackPartial} partial The array of string property names to remove from the Track class.
+     */
+    static setTrackPartial(partial: TrackPartial[]): void;
+    /**
+     * Checks if the provided argument is a valid Track.
+     * @param value The value to check.
+     * @returns {boolean} Whether the provided argument is a valid Track.
+     */
+    static isTrack(track: unknown): track is Track;
+    /**
+     * Checks if the provided argument is a valid Track array.
+     * @param value The value to check.
+     * @returns {boolean} Whether the provided argument is a valid Track array.
+     */
+    static isTrackArray(value: unknown): value is Track[];
+    /**
+     * Checks if the provided argument is a valid Track or Track array.
+     * @param value The value to check.
+     * @returns {boolean} Whether the provided argument is a valid Track or Track array.
+     */
+    static validate(value: unknown): value is Track | Track[];
+    /**
+     * Builds a Track from the raw data from Lavalink and a optional requester.
+     * @param data The raw data from Lavalink to build the Track from.
+     * @param requester The user who requested the track, if any.
+     * @param isAutoPlay Whether the track is autoplayed. Defaults to false.
+     * @returns The built Track.
+     */
+    static build<T = AnyUser>(data: TrackData, requester?: T, isAutoplay?: boolean): Track;
+    /**
+     * Validates a search result.
+     * @param result The search result to validate.
+     * @returns Whether the search result is valid.
+     */
+    static isErrorOrEmptySearchResult(result: SearchResult): result is ErrorOrEmptySearchResult;
+    /**
+     * Revives a track.
+     * @param track The track to revive.
+     * @returns The revived track.
+     */
+    static revive(track: Track): Track;
+}
+export declare abstract class AutoPlayUtils {
+    private static manager;
+    /**
+     * Initializes the AutoPlayUtils class with the given manager.
+     * @param manager The manager instance to use.
+     * @hidden
+     */
+    static init(manager: Manager): Promise<void>;
+    /**
+     * 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[]>;
+    /**
+     * 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: 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;
+    private static isPlaylistRawData;
+    private static isTrackData;
+    private static isTrackDataArray;
+    static buildTracksFromResponse<T>(recommendedResult: LavalinkResponse, requester?: T): Track[];
+}
+export declare abstract class PlayerUtils {
+    private static manager;
+    /**
+     * Initializes the PlayerUtils class with the given manager.
+     * @param manager The manager instance to use.
+     * @hidden
+     */
+    static init(manager: Manager): void;
+    /**
+     * Serializes a Player instance to avoid circular references.
+     * @param player The Player instance to serialize
+     * @returns The serialized Player instance
+     */
+    static serializePlayer(player: Player): Promise<SerializedPlayerState> | null;
+    /**
+     * Gets the base directory for player data.
+     */
+    static getPlayersBaseDir(): string;
+    /**
+     * Gets the path to the player's directory.
+     */
+    static getGuildDir(guildId: string): string;
+    /**
+     * Gets the path to the player's state file.
+     */
+    static getPlayerStatePath(guildId: string): string;
+    /**
+     * Gets the path to the player's current track file.
+     */
+    static getPlayerCurrentPath(guildId: string): string;
+    /**
+     * Gets the path to the player's queue file.
+     */
+    static getPlayerQueuePath(guildId: string): string;
+    /**
+     * Gets the path to the player's previous tracks file.
+     */
+    static getPlayerPreviousPath(guildId: string): string;
+    /**
+     * Gets the Redis key for player storage.
+     */
+    static getRedisKey(): string;
+}
+/** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
+export declare abstract class Structure {
+    /**
+     * Extends a class.
+     * @param name
+     * @param extender
+     */
+    static extend<K extends keyof Extendable, T extends Extendable[K]>(name: K, extender: (target: Extendable[K]) => T): T;
+    /**
+     * Get a structure from available structures by name.
+     * @param name
+     */
+    static get<K extends keyof Extendable>(name: K): Extendable[K];
+}
+export declare abstract class JSONUtils {
+    static safe<T>(obj: T, space?: number): string;
+    static serializeTrack(track: Track): string;
+}

package/dist/structures/Utils.js

@@ -9,9 +9,11 @@ const Enums_1 = require("./Enums");
 const path_1 = tslib_1.__importDefault(require("path"));
 const safe_stable_stringify_1 = tslib_1.__importDefault(require("safe-stable-stringify"));
 const MagmastreamError_1 = require("./MagmastreamError");
+// import { isPlainObject } from "lodash";
 // import playwright from "playwright";
 /** @hidden */
 const SIZES = ["0", "1", "2", "3", "default", "mqdefault", "hqdefault", "maxresdefault"];
+const REQUIRED_TRACK_KEYS = ["track", "title", "uri"];
 class TrackUtils {
     static trackPartial = null;
     static manager;
@@ -39,19 +41,12 @@ class TrackUtils {
         const defaultProperties = [
             Enums_1.TrackPartial.Track,
             Enums_1.TrackPartial.Title,
-            Enums_1.TrackPartial.Identifier,
             Enums_1.TrackPartial.Author,
             Enums_1.TrackPartial.Duration,
-            Enums_1.TrackPartial.Isrc,
-            Enums_1.TrackPartial.IsSeekable,
-            Enums_1.TrackPartial.IsStream,
             Enums_1.TrackPartial.Uri,
-            Enums_1.TrackPartial.ArtworkUrl,
             Enums_1.TrackPartial.SourceName,
-            Enums_1.TrackPartial.ThumbNail,
+            Enums_1.TrackPartial.ArtworkUrl,
             Enums_1.TrackPartial.Requester,
-            Enums_1.TrackPartial.PluginInfo,
-            Enums_1.TrackPartial.CustomData,
         ];
         /** The array of property names that will be removed from the Track class */
         this.trackPartial = Array.from(new Set([...defaultProperties, ...partial]));
@@ -61,25 +56,30 @@ class TrackUtils {
     }
     /**
      * Checks if the provided argument is a valid Track.
-     * If provided an array then every element will be checked.
-     * @param trackOrTracks The Track or array of Tracks to check.
+     * @param value The value to check.
      * @returns {boolean} Whether the provided argument is a valid Track.
      */
-    static validate(trackOrTracks) {
-        if (typeof trackOrTracks !== "object" || trackOrTracks === null) {
+    static isTrack(track) {
+        if (typeof track !== "object" || track === null)
             return false;
-        }
-        const isValidTrack = (track) => {
-            if (typeof track !== "object" || track === null) {
-                return false;
-            }
-            const t = track;
-            return (typeof t.track === "string" && typeof t.title === "string" && typeof t.identifier === "string" && typeof t.isrc === "string" && typeof t.uri === "string");
-        };
-        if (Array.isArray(trackOrTracks)) {
-            return trackOrTracks.every(isValidTrack);
-        }
-        return isValidTrack(trackOrTracks);
+        const t = track;
+        return REQUIRED_TRACK_KEYS.every((key) => typeof t[key] === "string");
+    }
+    /**
+     * Checks if the provided argument is a valid Track array.
+     * @param value The value to check.
+     * @returns {boolean} Whether the provided argument is a valid Track array.
+     */
+    static isTrackArray(value) {
+        return Array.isArray(value) && value.every(this.isTrack);
+    }
+    /**
+     * Checks if the provided argument is a valid Track or Track array.
+     * @param value The value to check.
+     * @returns {boolean} Whether the provided argument is a valid Track or Track array.
+     */
+    static validate(value) {
+        return this.isTrack(value) || this.isTrackArray(value);
     }
     /**
      * Builds a Track from the raw data from Lavalink and a optional requester.
@@ -544,8 +544,7 @@ class AutoPlayUtils {
         return typeof data === "object" && data !== null && "encoded" in data && "info" in data;
     }
     static isTrackDataArray(data) {
-        return (Array.isArray(data) &&
-            data.every((track) => typeof track === "object" && track !== null && "encoded" in track && "info" in track && typeof track.encoded === "string"));
+        return (Array.isArray(data) && data.every((track) => typeof track === "object" && track !== null && "encoded" in track && "info" in track && typeof track.encoded === "string"));
     }
     static buildTracksFromResponse(recommendedResult, requester) {
         if (!recommendedResult)
@@ -624,64 +623,129 @@ class PlayerUtils {
      * @returns The serialized Player instance
      */
     static async serializePlayer(player) {
+        const isNonSerializable = (value) => {
+            if (typeof value === "function" || typeof value === "symbol")
+                return true;
+            if (typeof value === "object" && value !== null) {
+                const ctorName = value.constructor?.name ?? "";
+                return (value instanceof Map ||
+                    value instanceof Set ||
+                    value instanceof WeakMap ||
+                    value instanceof WeakSet ||
+                    ctorName === "Timeout" ||
+                    ctorName === "Socket" ||
+                    ctorName === "TLSSocket" ||
+                    ctorName === "EventEmitter");
+            }
+            return false;
+        };
+        const safeSerialize = (obj) => {
+            if (!obj || typeof obj !== "object")
+                return obj;
+            const result = {};
+            for (const [k, v] of Object.entries(obj)) {
+                if (!isNonSerializable(v)) {
+                    result[k] = v;
+                }
+            }
+            return result;
+        };
         try {
-            const current = await player.queue.getCurrent();
-            const tracks = await player.queue.getTracks();
-            const previous = await player.queue.getPrevious();
-            const serializeTrack = (track) => ({
-                ...track,
-                requester: track.requester ? { id: track.requester.id, username: track.requester.username } : null,
-            });
-            const safeNode = player.node
-                ? JSON.parse(JSON.stringify(player.node, (key, value) => {
-                    if (key === "rest" || key === "players" || key === "shards" || key === "manager")
-                        return undefined;
-                    return value;
-                }))
-                : null;
-            return JSON.parse(JSON.stringify(player, (key, value) => {
-                if (key === "manager")
+            const [current, tracks, previous] = await Promise.all([player.queue.getCurrent(), player.queue.getTracks(), player.queue.getPrevious()]);
+            const serializeTrack = (track) => {
+                if (!track || !track.identifier)
                     return null;
-                if (key === "node")
-                    return safeNode;
-                if (key === "filters") {
+                try {
                     return {
-                        distortion: value?.distortion ?? null,
-                        equalizer: value?.equalizer ?? [],
-                        karaoke: value?.karaoke ?? null,
-                        rotation: value?.rotation ?? null,
-                        timescale: value?.timescale ?? null,
-                        vibrato: value?.vibrato ?? null,
-                        reverb: value?.reverb ?? null,
-                        volume: value?.volume ?? 1.0,
-                        bassBoostlevel: value?.bassBoostlevel ?? null,
-                        filterStatus: value?.filtersStatus ? { ...value.filtersStatus } : {},
+                        ...track,
+                        requester: track.requester ? { id: track.requester.id, username: track.requester.username } : null,
+                        displayThumbnail: undefined,
                     };
                 }
-                if (key === "queue") {
-                    return {
-                        current: current ? serializeTrack(current) : null,
-                        tracks: tracks.map(serializeTrack),
-                        previous: previous.map(serializeTrack),
-                    };
+                catch {
+                    return null;
                 }
-                if (key === "data") {
-                    return {
-                        clientUser: value?.Internal_AutoplayUser ?? null,
-                        nowPlayingMessage: value?.nowPlayingMessage ?? null,
-                    };
+            };
+            const safeCurrent = current ? serializeTrack(current) : null;
+            const safeTracks = tracks.map(serializeTrack).filter((t) => t !== null);
+            const safePrevious = previous.map(serializeTrack).filter((t) => t !== null);
+            let safeNode = null;
+            if (player.node) {
+                try {
+                    safeNode = JSON.parse(JSON.stringify(player.node, (key, value) => {
+                        if (["rest", "players", "shards", "manager"].includes(key))
+                            return undefined;
+                        if (isNonSerializable(value))
+                            return undefined;
+                        return value;
+                    }));
+                }
+                catch {
+                    safeNode = null;
                 }
-                return value;
-            }));
+            }
+            const serializableData = player.getSerializableData();
+            const nowPlayingMessage = serializableData.nowPlayingMessage;
+            delete serializableData.nowPlayingMessage;
+            const snapshot = {
+                clusterId: player.clusterId,
+                options: player.options,
+                voiceState: player.voiceState,
+                guildId: player.guildId,
+                voiceChannelId: player.voiceChannelId ?? null,
+                textChannelId: player.textChannelId ?? null,
+                volume: player.volume,
+                paused: player.paused,
+                playing: player.playing,
+                position: player.position,
+                trackRepeat: player.trackRepeat,
+                queueRepeat: player.queueRepeat,
+                dynamicRepeat: player.dynamicRepeat,
+                node: safeNode,
+                queue: {
+                    current: safeCurrent,
+                    tracks: safeTracks,
+                    previous: safePrevious,
+                },
+                filters: player.filters
+                    ? {
+                        distortion: player.filters.distortion ?? null,
+                        equalizer: player.filters.equalizer ?? [],
+                        karaoke: player.filters.karaoke ?? null,
+                        rotation: player.filters.rotation ?? null,
+                        timescale: player.filters.timescale ?? null,
+                        vibrato: player.filters.vibrato ?? null,
+                        reverb: player.filters.reverb ?? null,
+                        volume: player.filters.volume ?? 1.0,
+                        bassBoostlevel: player.filters.bassBoostlevel ?? null,
+                        filterStatus: { ...player.filters.filtersStatus },
+                    }
+                    : null,
+                data: {
+                    ...safeSerialize(serializableData),
+                    nowPlayingMessage: nowPlayingMessage
+                        ? {
+                            id: String(nowPlayingMessage.id),
+                            channelId: nowPlayingMessage.channelId,
+                            guildId: nowPlayingMessage.guildId,
+                        }
+                        : null,
+                },
+            };
+            // Sanity check
+            JSON.stringify(snapshot);
+            return snapshot;
         }
         catch (err) {
-            throw err instanceof MagmastreamError_1.MagmaStreamError
+            const error = err instanceof MagmastreamError_1.MagmaStreamError
                 ? err
                 : new MagmastreamError_1.MagmaStreamError({
-                    code: Enums_1.MagmaStreamErrorCode.MANAGER_SEARCH_FAILED,
-                    message: `An error occurred while searching: ${err instanceof Error ? err.message : String(err)}`,
+                    code: Enums_1.MagmaStreamErrorCode.UTILS_PLAYER_SERIALIZE_FAILED,
+                    message: `An error occurred while serializing player: ${err instanceof Error ? err.message : String(err)}`,
                     cause: err instanceof Error ? err : undefined,
                 });
+            console.error(error);
+            return null;
         }
     }
     /**
@@ -720,6 +784,16 @@ class PlayerUtils {
     static getPlayerPreviousPath(guildId) {
         return path_1.default.join(this.getGuildDir(guildId), "previous.json");
     }
+    /**
+     * Gets the Redis key for player storage.
+     */
+    static getRedisKey() {
+        const cfg = this.manager.options.stateStorage.redisConfig;
+        // Default prefix
+        let prefix = (cfg.prefix ?? "magmastream:").trim();
+        prefix = prefix.replace(/:+$/g, "") + ":";
+        return prefix;
+    }
 }
 exports.PlayerUtils = PlayerUtils;
 /** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */

package/dist/utils/filtersEqualizers.d.ts

@@ -0,0 +1,16 @@
+/** Represents an equalizer band. */
+export interface Band {
+    /** The index of the equalizer band (0-12). */
+    band: number;
+    /** The gain value of the equalizer band (in decibels). */
+    gain: number;
+}
+export declare const bassBoostEqualizer: Band[];
+export declare const softEqualizer: Band[];
+export declare const tvEqualizer: Band[];
+export declare const trebleBassEqualizer: Band[];
+export declare const vaporwaveEqualizer: Band[];
+export declare const popEqualizer: Band[];
+export declare const electronicEqualizer: Band[];
+export declare const radioEqualizer: Band[];
+export declare const demonEqualizer: Band[];

package/dist/utils/managerCheck.d.ts

@@ -0,0 +1,7 @@
+import { ManagerOptions } from "../structures/Types";
+/**
+ * Validates the provided ManagerOptions object.
+ * @param options - The options to validate.
+ * @throws {MagmaStreamError} Throws if any required option is missing or invalid.
+ */
+export default function managerCheck(options: ManagerOptions): void;

package/dist/utils/nodeCheck.d.ts

@@ -0,0 +1,7 @@
+import { NodeOptions } from "../structures/Types";
+/**
+ * Validates the provided NodeOptions object.
+ * @param options - The options to validate.
+ * @throws {MagmaStreamError} Throws if any required option is missing or invalid.
+ */
+export default function nodeCheck(options: NodeOptions): void;

package/dist/utils/playerCheck.d.ts

@@ -0,0 +1,7 @@
+import { PlayerOptions } from "../structures/Types";
+/**
+ * Validates the provided PlayerOptions object.
+ * @param options - The options to validate.
+ * @throws {MagmaStreamError} Throws if any required option is missing or invalid.
+ */
+export default function playerCheck(options: PlayerOptions): void;

package/dist/wrappers/discord.js.d.ts

@@ -0,0 +1,15 @@
+import { Manager as BaseManager } from "../structures/Manager";
+import type { GatewayVoiceStateUpdate } from "discord-api-types/v10";
+import { Client, Guild, User } from "discord.js";
+import { AnyUser, ManagerOptions } from "../structures/Types";
+export * from "../index";
+/**
+ * Discord.js wrapper for Magmastream.
+ */
+export declare class DiscordJSManager extends BaseManager {
+    readonly client: Client;
+    constructor(client: Client, options?: ManagerOptions);
+    protected send(packet: GatewayVoiceStateUpdate): void;
+    resolveUser(user: AnyUser | string): Promise<User | AnyUser>;
+    resolveGuild(guildId: string): Guild | null;
+}

package/dist/wrappers/discord.js.js

@@ -4,7 +4,10 @@ exports.DiscordJSManager = void 0;
 const tslib_1 = require("tslib");
 const Manager_1 = require("../structures/Manager");
 const discord_js_1 = require("discord.js");
-const [major, minor] = discord_js_1.version.split(".").map(Number);
+const discord_js_2 = require("discord.js");
+const MagmastreamError_1 = require("../structures/MagmastreamError");
+const Enums_1 = require("../structures/Enums");
+const [major, minor] = discord_js_2.version.split(".").map(Number);
 tslib_1.__exportStar(require("../index"), exports);
 /**
  * Discord.js wrapper for Magmastream.
@@ -14,6 +17,12 @@ class DiscordJSManager extends Manager_1.Manager {
     constructor(client, options) {
         super(options);
         this.client = client;
+        if (!this.client.options.intents.has(discord_js_1.GatewayIntentBits.GuildVoiceStates)) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.INTENT_MISSING,
+                message: "[Custom Wrapper] Your Discord.js client must have the GuildVoiceStates intent enabled.",
+            });
+        }
         const attachReadyHandler = () => {
             const handler = () => {
                 if (!this.options.clientId)
@@ -21,11 +30,11 @@ class DiscordJSManager extends Manager_1.Manager {
             };
             // Only attach clientReady if Discord.js >= 14.22.0
             if (major > 14 || (major === 14 && minor >= 22)) {
-                client.once("clientReady", handler);
+                this.client.once("clientReady", handler);
             }
             // Only attach ready if Discord.js < 14.22.0
             if (major < 14 || (major === 14 && minor < 22)) {
-                client.once("ready", handler);
+                this.client.once("ready", handler);
             }
         };
         attachReadyHandler();
@@ -39,7 +48,7 @@ class DiscordJSManager extends Manager_1.Manager {
             guild.shard.send(packet);
     }
     async resolveUser(user) {
-        const id = typeof user === "string" ? user : user.id;
+        const id = typeof user === "string" ? user : String(user.id);
         const cached = this.client.users.cache.get(id);
         if (cached)
             return cached;
@@ -51,5 +60,11 @@ class DiscordJSManager extends Manager_1.Manager {
             return { id, username: typeof user === "string" ? undefined : user.username };
         }
     }
+    resolveGuild(guildId) {
+        const cached = this.client.guilds.cache.get(guildId);
+        if (cached)
+            return cached;
+        return null;
+    }
 }
 exports.DiscordJSManager = DiscordJSManager;

package/dist/wrappers/discordeno.d.ts

@@ -0,0 +1,19 @@
+import { GatewayVoiceStateUpdate } from "discord-api-types/v10";
+import { Manager as BaseManager } from "../structures/Manager";
+import { Bot, User } from "@discordeno/bot";
+import { AnyGuild, AnyUser, ManagerOptions } from "../structures/Types";
+export * from "../index";
+/**
+ * Discordeno wrapper for Magmastream.
+ */
+export declare class DiscordenoManager extends BaseManager {
+    readonly client: Bot;
+    constructor(client: Bot, options?: ManagerOptions);
+    protected send(packet: GatewayVoiceStateUpdate): void;
+    /**
+     * Resolve a user by ID or partial info.
+     * Uses user-provided cache getter if available, otherwise falls back to minimal info.
+     */
+    resolveUser(user: AnyUser | string): Promise<User | AnyUser>;
+    resolveGuild(guildId: string): AnyGuild;
+}

package/dist/wrappers/discordeno.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordenoManager = void 0;
+const tslib_1 = require("tslib");
+const Manager_1 = require("../structures/Manager");
+const bot_1 = require("@discordeno/bot");
+const Enums_1 = require("../structures/Enums");
+const MagmastreamError_1 = require("../structures/MagmastreamError");
+tslib_1.__exportStar(require("../index"), exports);
+/**
+ * Discordeno wrapper for Magmastream.
+ */
+class DiscordenoManager extends Manager_1.Manager {
+    client;
+    constructor(client, options) {
+        super(options);
+        this.client = client;
+        // Ensure GuildVoiceStates intent is enabled
+        const intents = this.client.gateway.intents;
+        if (!(intents & bot_1.GatewayIntents.GuildVoiceStates)) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.INTENT_MISSING,
+                message: "[Custom Wrapper] Your Discordeno client must have the GuildVoiceStates intent enabled.",
+            });
+        }
+        // Chain READY event
+        const oldReady = this.client.handlers.READY;
+        this.client.handlers.READY = (bot, payload, shardId) => {
+            if (oldReady)
+                oldReady(bot, payload, shardId);
+            if (!this.options?.clientId)
+                this.options.clientId = this.client.applicationId.toString();
+        };
+        // Chain VOICE_STATE_UPDATE event
+        const oldVoiceState = this.client.handlers.VOICE_STATE_UPDATE;
+        this.client.handlers.VOICE_STATE_UPDATE = (bot, payload, shardId) => {
+            if (oldVoiceState)
+                oldVoiceState(bot, payload, shardId);
+            this.updateVoiceState(payload);
+        };
+        // Chain VOICE_SERVER_UPDATE event
+        const oldVoiceServer = this.client.handlers.VOICE_SERVER_UPDATE;
+        this.client.handlers.VOICE_SERVER_UPDATE = (bot, payload, shardId) => {
+            if (oldVoiceServer)
+                oldVoiceServer(bot, payload, shardId);
+            this.updateVoiceState(payload);
+        };
+    }
+    // Send voice state updates to the guild shard
+    send(packet) {
+        this.client.gateway.sendPayload(this.client.gateway.calculateShardId(packet.d.guild_id), {
+            op: bot_1.GatewayOpcodes.VoiceStateUpdate,
+            d: packet.d,
+        });
+    }
+    /**
+     * Resolve a user by ID or partial info.
+     * Uses user-provided cache getter if available, otherwise falls back to minimal info.
+     */
+    async resolveUser(user) {
+        const id = typeof user === "string" ? user : String(user.id);
+        // Try user-provided cache getter
+        const cached = this.getUserFromCache(id);
+        if (cached)
+            return cached;
+        // Fallback: return minimal info
+        return {
+            id,
+            username: typeof user === "string" ? undefined : user.username,
+        };
+    }
+    resolveGuild(guildId) {
+        // Try user-provided cache getter
+        return this.getGuildFromCache(guildId);
+    }
+}
+exports.DiscordenoManager = DiscordenoManager;