damonjs/dist/src/Modules/Interfaces.d.ts

A modified Shoukaku wrapper with enhanced queue support.

import { DamonJs } from '../DamonJs';
import { DamonJsPlayer, DamonJsQueue } from '../../Index';
import { DamonJsTrack } from '../Managers/Supports/DamonJsTrack';
import { PlayerUpdate, Track, TrackEndEvent, TrackExceptionEvent, TrackStuckEvent, Utils, WebSocketClosedEvent } from 'shoukaku';
import { Snowflake } from 'discord.js';
export interface DamonJsOptions {
    /** Default search engine if no engine was provided. Default to youtube */
    defaultSearchEngine: SearchEngines;
    /** play spam config until destroys */
    skipSpam?: {
        rule: {
            maxhits: number;
            timeFrame: number;
            cooldown: number;
        };
        destroy: {
            timeFrame: number;
            maxhits: number;
        };
    };
    trackEnd?: {
        skip: boolean;
    };
    trackException?: {
        skip: boolean;
    };
    trackStuck?: {
        skip: boolean;
    };
    trackResolveError?: {
        skip: boolean;
    };
    /** DamonJs plugins */
    plugins?: DamonJsPlugin[];
    /** Source that will be forced to resolve when playing it */
    sourceForceResolve?: string[];
    /** The track resolver. Make sure you set <DamonJsTrack>.track for it to work. (I'm not responsible for any error during playback if you don't set it right) */
    trackResolver?: (this: DamonJsTrack, options?: ResolveOptions) => Promise<boolean>;
    /** The default youtube thumbnail's size */
    defaultYoutubeThumbnail?: YoutubeThumbnail;
    /** Extend some of the Structures */
    extends?: {
        player?: Utils.Constructor<DamonJsPlayer>;
    };
}
export declare type SearchEngines = 'youtube' | 'soundcloud' | 'youtube_music' | string;
export declare type YoutubeThumbnail = 'default' | 'hqdefault' | 'mqdefault' | 'sddefault' | 'maxresdefault';
export interface Payload {
    /** The OP code */
    op: number;
    d: {
        guild_id: string;
        channel_id: string | null;
        self_mute: boolean;
        self_deaf: boolean;
    };
}
export declare const escapeRegExp: (str: string) => string;
export declare const SourceIDs: {
    youtube: string;
    youtube_music: string;
    soundcloud: string;
};
export interface DamonJsPlayerOptions {
    /** The player's text ID */
    textId: Snowflake;
    volume: number;
    data?: [string, any][];
    extends?: {
        queue?: Utils.Constructor<DamonJsQueue>;
    };
}
export interface ResolveOptions {
    overwrite?: boolean;
    forceResolve?: boolean;
    player: DamonJsPlayer;
}
export interface CreatePlayerOptions {
    /** The player's guild ID */
    guildId: Snowflake;
    /** The player's voice ID */
    voiceId: Snowflake;
    /** The player's text ID */
    textId: Snowflake;
    /** Whether the bot should deafen */
    deaf?: boolean;
    /** Whether the bot should mute */
    mute?: boolean;
    /** The player's guild's shardId */
    shardId?: number;
    /** The player's volume */
    volume?: number;
    /** The player's data, usable when you extends it */
    data?: [string, any][];
}
export interface RawTrack {
    encoded: string;
    info: {
        identifier: string;
        isSeekable: boolean;
        author: string;
        length: number;
        isStream: boolean;
        position: number;
        title: string;
        uri?: string;
        artworkUrl?: string;
        thumbnail?: string;
        isrc?: string;
        sourceName: string;
    };
    pluginInfo: unknown;
    _raw: Track;
}
export interface DamonJsEvents {
    playerDestroy: [player: DamonJsPlayer, track?: DamonJsTrack];
    playerCreate: [player: DamonJsPlayer];
    playerStart: [player: DamonJsPlayer, track: DamonJsTrack];
    playerEnd: [player: DamonJsPlayer, track: DamonJsTrack, data: TrackEndEvent];
    playerEmpty: [player: DamonJsPlayer, track?: DamonJsTrack];
    playerClosed: [player: DamonJsPlayer, data: WebSocketClosedEvent];
    playerUpdate: [player: DamonJsPlayer, track: DamonJsTrack, data: PlayerUpdate];
    playerException: [player: DamonJsPlayer, track: DamonJsTrack, data: TrackExceptionEvent];
    playerResumed: [player: DamonJsPlayer];
    playerStuck: [player: DamonJsPlayer, track: DamonJsTrack, data: TrackStuckEvent];
    playerResolveError: [player: DamonJsPlayer, track: DamonJsTrack, message?: string];
    playerMoved: [player: DamonJsPlayer, state: PlayerMovedState, channels: PlayerMovedChannels];
    initQueue: [player: DamonJsPlayer];
    playerError: [player: DamonJsPlayer, error: Error];
    debug: [player: DamonJsPlayer, message: string];
}
export declare enum Events {
    PlayerDestroy = "playerDestroy",
    PlayerCreate = "playerCreate",
    PlayerStart = "playerStart",
    PlayerEnd = "playerEnd",
    PlayerEmpty = "playerEmpty",
    PlayerClosed = "playerClosed",
    PlayerUpdate = "playerUpdate",
    PlayerException = "playerException",
    PlayerResumed = "playerResumed",
    PlayerStuck = "playerStuck",
    PlayerError = "playerError",
    PlayerResolveError = "playerResolveError",
    PlayerMoved = "playerMoved",
    Debug = "debug",
    InitQueue = "initQueue"
}
export interface PlayerMovedChannels {
    oldChannelId?: string | null;
    newChannelId?: string | null;
}
export declare enum PlayerMovedState {
    Unknown = "UNKNOWN",
    Joined = "JOINED",
    Left = "LEFT",
    Moved = "MOVED"
}
export declare enum LoopState {
    Track = "track",
    Queue = "queue",
    None = "none"
}
export interface DamonJsSearchOptions {
    requester: unknown;
    engine?: SearchEngines;
}
export interface DamonJsSearchResult {
    type: SearchResultTypes;
    playlistInfo?: {
        encoded: string;
        info: {
            name: string;
            selectedTrack: number;
        };
        pluginInfo: unknown;
    };
    tracks: DamonJsTrack[];
}
export declare enum SearchResultTypes {
    Playlist = "PLAYLIST",
    Track = "TRACK",
    Search = "SEARCH",
    Empty = "EMPTY",
    Error = "Error"
}
export declare const SupportedSources: string[];
export interface PlayOptions {
    pause?: boolean;
    startTime?: number;
    endTime?: number;
    replaceCurrent?: boolean;
}
export declare enum State {
    CONNECTING = 0,
    CONNECTED = 1,
    DISCONNECTING = 2,
    DISCONNECTED = 3
}
export declare enum PlayerState {
    CONNECTING = 0,
    CONNECTED = 1,
    DISCONNECTING = 2,
    DISCONNECTED = 3,
    DESTROYING = 4,
    DESTROYED = 5
}
export declare class DamonJsPlugin {
    load(damonjs: DamonJs): void;
    unload(damonjs: DamonJs): void;
}
export declare class DamonJsError extends Error {
    code: number;
    message: string;
    constructor(code: number, message: string);
}