ziplayer/dist/structures/PlayerManager.d.ts

A modular Discord voice player with plugin system

import { EventEmitter } from "events";
import { Player } from "./Player";
import { PlayerManagerOptions, PlayerOptions, SearchResult } from "../types";
export declare const getGlobalManager: () => PlayerManager | null;
/**
 * The main class for managing players across multiple Discord guilds.
 *
 * @example
 * // Basic setup with plugins and extensions
 * const manager = new PlayerManager({
 *   plugins: [
 *     new YouTubePlugin(),
 *     new SoundCloudPlugin(),
 *     new SpotifyPlugin(),
 *     new TTSPlugin({ defaultLang: "en" })
 *   ],
 *   extensions: [
 *     new voiceExt(null, { lang: "en-US" }),
 *     new lavalinkExt(null, {
 *       nodes: [{ host: "localhost", port: 2333, password: "youshallnotpass" }]
 *     })
 *   ],
 *   extractorTimeout: 10000
 * });
 *
 * // Create a player for a guild
 * const player = await manager.create(guildId, {
 *   tts: { interrupt: true, volume: 1 },
 *   leaveOnEnd: true,
 *   leaveTimeout: 30000
 * });
 *
 * // Get existing player
 * const existingPlayer = manager.get(guildId);
 * if (existingPlayer) {
 *   await existingPlayer.play("Never Gonna Give You Up", userId);
 * }
 */
export declare class PlayerManager extends EventEmitter {
    private static instance;
    private players;
    static default(opt?: PlayerOptions): Promise<Player>;
    private plugins;
    private extensions;
    private B_debug;
    private extractorTimeout;
    private debug;
    constructor(options?: PlayerManagerOptions);
    private withTimeout;
    private resolveGuildId;
    /**
     * Create a new player for a guild
     *
     * @param {string | {id: string}} guildOrId - Guild ID or guild object
     * @param {PlayerOptions} options - Player configuration options
     * @returns {Promise<Player>} The created player instance
     *
     * @example
     * // Create player with basic options
     * const player = await manager.create(guildId, {
     *   tts: { interrupt: true, volume: 1 },
     *   leaveOnEnd: true,
     *   leaveTimeout: 30000
     * });
     *
     * // Create player with advanced options
     * const advancedPlayer = await manager.create(guild, {
     *   volume: 0.8,
     *   quality: "high",
     *   selfDeaf: false,
     *   selfMute: false,
     *   tts: {
     *     createPlayer: true,
     *     interrupt: true,
     *     volume: 1.0,
     *     Max_Time_TTS: 30000
     *   },
     *   userdata: { customData: "example" }
     * });
     *
     * // Connect and play immediately
     * await player.connect(voiceChannel);
     * await player.play("Never Gonna Give You Up", userId);
     */
    create(guildOrId: string | {
        id: string;
    }, options?: PlayerOptions): Promise<Player>;
    /**
     * Get an existing player for a guild
     *
     * @param {string | {id: string}} guildOrId - Guild ID or guild object
     * @returns {Player | undefined} The player instance or undefined if not found
     * @example
     * // Get player by guild ID
     * const player = manager.get(guildId);
     * if (player) {
     *   await player.play("Never Gonna Give You Up", userId);
     * } else {
     *   console.log("No player found for this guild");
     * }
     *
     * // Get player by guild object
     * const playerFromGuild = manager.get(guild);
     * if (playerFromGuild) {
     *   playerFromGuild.setVolume(0.5);
     * }
     *
     * // Check if player exists before using
     * const existingPlayer = manager.get(guildId);
     * if (existingPlayer && existingPlayer.playing) {
     *   existingPlayer.pause();
     * }
     */
    get(guildOrId: string | {
        id: string;
    }): Player | undefined;
    /**
     * Get an existing player for a guild
     *
     * @param {string | {id: string}} guildOrId - Guild ID or guild object
     * @returns {Player | undefined} The player instance or undefined
     * @example
     * const player = manager.get(guildId);
     * if (player) {
     *   await player.play("song name", userId);
     * }
     */
    getPlayer(guildOrId: string | {
        id: string;
    }): Player | undefined;
    /**
     * Get all players
     *
     * @returns {Player[]} All player instances
     * @example
     * const players = manager.getall();
     * console.log(`Players: ${players.length}`);
     */
    getall(): Player[] | [];
    /**
     * Destroy a player and clean up resources
     *
     * @param {string | {id: string}} guildOrId - Guild ID or guild object
     * @returns {boolean} True if player was destroyed, false if not found
     * @example
     * // Destroy player by guild ID
     * const destroyed = manager.delete(guildId);
     * if (destroyed) {
     *   console.log("Player destroyed successfully");
     * } else {
     *   console.log("No player found to destroy");
     * }
     *
     * // Destroy player by guild object
     * const destroyedFromGuild = manager.delete(guild);
     * console.log(`Player destroyed: ${destroyedFromGuild}`);
     *
     * // Clean up all players
     * for (const [guildId, player] of manager.players) {
     *   const destroyed = manager.delete(guildId);
     *   console.log(`Destroyed player for ${guildId}: ${destroyed}`);
     * }
     */
    delete(guildOrId: string | {
        id: string;
    }): boolean;
    /**
     * Check if a player exists for a guild
     *
     * @param {string | {id: string}} guildOrId - Guild ID or guild object
     * @returns {boolean} True if player exists, false if not
     * @example
     * const exists = manager.has(guildId);
     * console.log(`Player exists: ${exists}`);
     */
    has(guildOrId: string | {
        id: string;
    }): boolean;
    get size(): number;
    get debugEnabled(): boolean;
    /**
     * Destroy all players
     *
     * @returns {void}
     * @example
     * manager.destroy();
     * console.log(`All players destroyed`);
     */
    destroy(): void;
    /**
     * Search using registered plugins without creating a Player.
     *
     * @param {string} query - The query to search for
     * @param {string} requestedBy - The user ID who requested the search
     * @returns {Promise<SearchResult>} The search result
     * @example
     * const result = await manager.search("Never Gonna Give You Up", userId);
     * console.log(`Search result: ${result.tracks.length} tracks`);
     */
    search(query: string, requestedBy: string): Promise<SearchResult>;
}
export declare function getInstance(): PlayerManager | null;
//# sourceMappingURL=PlayerManager.d.ts.map