for-modules 1.0.0

package/dist/Structures/Manager.d.ts

@@ -0,0 +1,192 @@
+import { LoadType, Plugin, TrackData, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, WebSocketClosedEvent } from "./Utils";
+import { Collection } from "@discordjs/collection";
+import { Node, NodeOptions } from "./Node";
+import { Player, PlayerOptions, Track, UnresolvedTrack } from "./Player";
+import { VoiceState } from "..";
+import { ClientUser, User } from "discord.js";
+import { TypedEmitter } from "tiny-typed-emitter";
+/**
+ * The main hub for interacting with Lavalink and using Magmastream,
+ */
+export declare class Manager extends TypedEmitter<ManagerEvents> {
+    static readonly DEFAULT_SOURCES: Record<SearchPlatform, string>;
+    /** The map of players. */
+    readonly players: Collection<string, Player>;
+    /** The map of nodes. */
+    readonly nodes: Collection<string, Node>;
+    /** The options that were set. */
+    readonly options: ManagerOptions;
+    private initiated;
+    caches: Collection<string, SearchResult>;
+    /** Returns the nodes that has the least load. */
+    get leastLoadNode(): Collection<string, Node>;
+    /** Returns the nodes that has the least amount of players. */
+    private get leastPlayersNode();
+    /** Returns a node based on priority. */
+    private get priorityNode();
+    /** Returns the node to use. */
+    get useableNodes(): Node;
+    /**
+     * Initiates the Manager class.
+     * @param options
+     */
+    constructor(options: ManagerOptions);
+    /**
+     * Initiates the Manager.
+     * @param clientId
+     */
+    init(clientId?: string): this;
+    /**
+     * Searches the enabled sources based off the URL or the `source` property.
+     * @param query
+     * @param requester
+     * @returns The search result.
+     */
+    search(query: string | SearchQuery, requester?: User | ClientUser): Promise<SearchResult>;
+    /**
+     * Decodes the base64 encoded tracks and returns a TrackData array.
+     * @param tracks
+     */
+    decodeTracks(tracks: string[]): Promise<TrackData[]>;
+    /**
+     * Decodes the base64 encoded track and returns a TrackData.
+     * @param track
+     */
+    decodeTrack(track: string): Promise<TrackData>;
+    /**
+     * Creates a player or returns one if it already exists.
+     * @param options
+     */
+    create(options: PlayerOptions): Player;
+    /**
+     * Returns a player or undefined if it does not exist.
+     * @param guild
+     */
+    get(guild: string): Player | undefined;
+    /**
+     * Destroys a player if it exists.
+     * @param guild
+     */
+    destroy(guild: string): void;
+    /**
+     * Creates a node or returns one if it already exists.
+     * @param options
+     */
+    createNode(options: NodeOptions): Node;
+    /**
+     * Destroys a node if it exists.
+     * @param identifier
+     */
+    destroyNode(identifier: string): void;
+    /**
+     * Sends voice data to the Lavalink server.
+     * @param data
+     */
+    updateVoiceState(data: VoicePacket | VoiceServer | VoiceState): Promise<void>;
+}
+export interface Payload {
+    /** The OP code */
+    op: number;
+    d: {
+        guild_id: string;
+        channel_id: string | null;
+        self_mute: boolean;
+        self_deaf: boolean;
+    };
+}
+export interface ManagerOptions {
+    /** Use priority mode over least amount of player or load? */
+    usePriority?: boolean;
+    /** Use the least amount of players or least load? */
+    useNode?: "leastLoad" | "leastPlayers";
+    /** The array of nodes to connect to. */
+    nodes?: NodeOptions[];
+    /** The client ID to use. */
+    clientId?: string;
+    /** Value to use for the `Client-Name` header. */
+    clientName?: string;
+    /** The shard count. */
+    shards?: number;
+    /** A array of plugins to use. */
+    plugins?: Plugin[];
+    /** Whether players should automatically play the next song. */
+    autoPlay?: boolean;
+    /** An array of track properties to keep. `track` will always be present. */
+    trackPartial?: string[];
+    /** The default search platform to use, can be "youtube", "youtube music", "soundcloud" or deezer. */
+    defaultSearchPlatform?: SearchPlatform;
+    /** Whether the YouTube video titles should be replaced if the Author does not exactly match. */
+    replaceYouTubeCredentials?: boolean;
+    caches: {
+        /** Whether to cache the search results. */
+        enabled: boolean;
+        /** The time to cache the search results. */
+        time: number;
+    };
+    /**
+     * Function to send data to the websocket.
+     * @param id
+     * @param payload
+     */
+    send(id: string, payload: Payload): void;
+}
+export type SearchPlatform = "deezer" | "soundcloud" | "youtube music" | "youtube" | "spotify" | "jiosaavn" | "tidal" | "applemusic" | "bandcamp" | "tiktok";
+export interface SearchQuery {
+    /** The source to search from. */
+    source?: SearchPlatform | string;
+    /** The query to search for. */
+    query: string;
+}
+export interface LavalinkResponse {
+    loadType: LoadType;
+    data: TrackData[] | PlaylistRawData;
+}
+export interface SearchResult {
+    /** The load type of the result. */
+    loadType: LoadType;
+    /** The array of tracks from the result. */
+    tracks: Track[];
+    /** The playlist info if the load type is 'playlist'. */
+    playlist?: PlaylistData;
+}
+export interface PlaylistRawData {
+    info: {
+        /** The playlist name. */
+        name: string;
+    };
+    /** Addition info provided by plugins. */
+    pluginInfo: object;
+    /** The tracks of the playlist */
+    tracks: TrackData[];
+}
+export interface PlaylistData {
+    /** The playlist name. */
+    name: string;
+    /** The length of the playlist. */
+    duration: number;
+    /** The songs of the playlist. */
+    tracks: Track[];
+}
+export interface ManagerEvents {
+    NodeCreate: (node: Node) => void;
+    NodeDestroy: (node: Node) => void;
+    NodeConnect: (node: Node) => void;
+    NodeReconnect: (node: Node) => void;
+    NodeDisconnect: (node: Node, reason: {
+        code?: number;
+        reason?: string;
+    }) => void;
+    NodeError: (node: Node, error: Error) => void;
+    NodeRaw: (payload: unknown) => void;
+    PlayerCreate: (player: Player) => void;
+    PlayerDestroy: (player: Player) => void;
+    PlayerStateUpdate: (oldPlayer: Player, newPlayer: Player) => void;
+    PlayerMove: (player: Player, initChannel: string, newChannel: string) => void;
+    PlayerDisconnect: (player: Player, oldChannel: string) => void;
+    QueueEnd: (player: Player, track: Track | UnresolvedTrack, payload: TrackEndEvent) => void;
+    SocketClosed: (player: Player, payload: WebSocketClosedEvent) => void;
+    TrackStart: (player: Player, track: Track, payload: TrackStartEvent) => void;
+    TrackEnd: (player: Player, track: Track, payload: TrackEndEvent) => void;
+    TrackStuck: (player: Player, track: Track, payload: TrackStuckEvent) => void;
+    TrackError: (player: Player, track: Track | UnresolvedTrack, payload: TrackExceptionEvent) => void;
+}