import EventEmitter from 'node:events';
import type { Awaitable } from 'discord.js';
import type { Command } from '../../structures/Command';
import type { Component } from '../../structures/Component';
import type { Listener } from '../../structures/Listener';
import type { Plugin } from '../../structures/Plugin';
import type { AutocompleteContext } from '../../structures/contexts/AutocompleteContext';
import type { CommandContext } from '../../structures/contexts/CommandContext';
import type { ComponentContext } from '../../structures/contexts/ComponentContext';
export declare enum Events {
    'HANDLER_RUN' = "handlerRun",
    'HANDLER_ERROR' = "handlerError",
    'COMMAND_HANDLER_RUN' = "commandHandlerRun",
    'COMMAND_HANDLER_ERROR' = "commandHandlerError",
    'AUTOCOMPLETE_HANDLER_RUN' = "autoCompleteHandlerRun",
    'AUTOCOMPLETE_HANDLER_ERROR' = "autoCompleteHandlerError",
    'COMPONENT_HANDLER_RUN' = "componentHandlerRun",
    'COMPONENT_HANDLER_ERROR' = "componentHandlerError",
    'COMMAND_REGISTERED' = "commandRegistered",
    'COMMAND_UNREGISTERED' = "commandUnregistered",
    'COMPONENT_REGISTERED' = "componentRegistered",
    'COMPONENT_UNREGISTERED' = "componentUnregistered",
    'LISTENER_REGISTERED' = "listenerRegistered",
    'LISTENER_UNREGISTERED' = "listenerUnregistered",
    'PLUGIN_REGISTERED' = "pluginRegistered"
}
export interface LoggerEvents {
    /**
     * Emitted when a handler is run.
     * @event Logger#handlerRun
     * @param {import('../../structures/contexts/AutocompleteContext')|import('../../structures/contexts/CommandContext')|import('../../structures/contexts/ComponentContext')} ctx The type of handler.
     */
    handlerRun: [ctx: AutocompleteContext | CommandContext | ComponentContext];
    /**
     * Emitted when a handler errors.
     * @event Logger#handlerError
     * @param {import('../../structures/contexts/AutocompleteContext')|import('../../structures/contexts/CommandContext')|import('../../structures/contexts/ComponentContext')} ctx The type of handler.
     * @param {any} error The error that occurred.
     */
    handlerError: [
        ctx: AutocompleteContext | CommandContext | ComponentContext,
        error: any
    ];
    /**
     * Emitted when a command handler is run.
     * @event Logger#commandHandlerRun
     * @param {import('../../structures/contexts/CommandContext')} ctx The command context.
     */
    commandHandlerRun: [ctx: CommandContext];
    /**
     * Emitted when a command handler errors.
     * @event Logger#commandHandlerError
     * @param {import('../../structures/contexts/CommandContext')} ctx The command context.
     * @param {any} error The error that occurred.
     */
    commandHandlerError: [ctx: CommandContext, error: any];
    /**
     * Emitted when an auto complete handler is run.
     * @event Logger#autoCompleteHandlerRun
     * @param {import('../../structures/contexts/AutocompleteContext')} ctx The auto complete context.
     */
    autoCompleteHandlerRun: [ctx: AutocompleteContext];
    /**
     * Emitted when an auto complete handler errors.
     * @event Logger#autoCompleteHandlerError
     * @param {import('../../structures/contexts/AutocompleteContext')} ctx The auto complete context.
     * @param {any} error The error that occurred.
     */
    autoCompleteHandlerError: [ctx: AutocompleteContext, error: any];
    /**
     * Emitted when a component handler is run.
     * @event Logger#componentHandlerRun
     * @param {import('../../structures/contexts/ComponentContext')} ctx The component context.
     */
    componentHandlerRun: [ctx: ComponentContext];
    /**
     * Emitted when a component handler errors.
     * @event Logger#componentHandlerError
     * @param {import('../../structures/contexts/ComponentContext')} ctx The component context.
     * @param {any} error The error that occurred.
     */
    componentHandlerError: [ctx: ComponentContext, error: any];
    /**
     * Emitted when a command is registered.
     * @event Logger#commandRegistered
     * @param {import('../../structures/Command')} command The command that was registered.
     */
    commandRegistered: [command: Command];
    /**
     * Emitted when a command is unregistered.
     * @event Logger#commandUnregistered
     * @param {import('../../structures/Command')} command The command that was unregistered.
     */
    commandUnregistered: [command: Command];
    /**
     * Emitted when a component is registered.
     * @event Logger#componentRegistered
     * @param {import('../../structures/Component')} component The component that was registered.
     */
    componentRegistered: [component: Component];
    /**
     * Emitted when a component is unregistered.
     * @event Logger#componentUnregistered
     * @param {import('../../structures/Component')} component The component that was unregistered.
     */
    componentUnregistered: [component: Component];
    /**
     * Emitted when a listener is registered.
     * @event Logger#listenerRegistered
     * @param {import('../../structures/Listener')} listener The listener that was registered.
     */
    listenerRegistered: [listener: Listener];
    /**
     * Emitted when a listener is unregistered.
     * @event Logger#listenerUnregistered
     * @param {import('../../structures/Listener')} listener The listener that was unregistered.
     */
    listenerUnregistered: [listener: Listener];
    /**
     * Emitted when a plugin is registered.
     * @event Logger#pluginRegistered
     * @param {import('../../structures/Plugin')} plugin The plugin that was registered.
     */
    pluginRegistered: [plugin: Plugin];
}
export declare interface ILogger {
    on<U extends keyof LoggerEvents>(event: U, listener: LoggerEvents[U]): this;
    on<K extends keyof LoggerEvents>(event: K, listener: (...args: LoggerEvents[K]) => Awaitable<void>): this;
    on<S extends string | symbol>(event: Exclude<S, keyof LoggerEvents>, listener: (...args: any[]) => Awaitable<void>): this;
    once<K extends keyof LoggerEvents>(event: K, listener: (...args: LoggerEvents[K]) => Awaitable<void>): this;
    once<S extends string | symbol>(event: Exclude<S, keyof LoggerEvents>, listener: (...args: any[]) => Awaitable<void>): this;
    emit<K extends keyof LoggerEvents>(event: K, ...args: LoggerEvents[K]): boolean;
    emit<S extends string | symbol>(event: Exclude<S, keyof LoggerEvents>, ...args: unknown[]): boolean;
    off<K extends keyof LoggerEvents>(event: K, listener: (...args: LoggerEvents[K]) => Awaitable<void>): this;
    off<S extends string | symbol>(event: Exclude<S, keyof LoggerEvents>, listener: (...args: any[]) => Awaitable<void>): this;
    removeAllListeners<K extends keyof LoggerEvents>(event?: K): this;
    removeAllListeners<S extends string | symbol>(event?: Exclude<S, keyof LoggerEvents>): this;
}
export declare const enum LogLevel {
    /**
     * Logs everything.
     * @type {number}
     * @default
     */
    TRACE = 1,
    /**
     * Logs everything except trace messages.
     * @type {number}
     */
    DEBUG = 2,
    /**
     * Logs everything except trace and debug messages.
     * @type {number}
     */
    INFO = 3,
    /**
     * Logs everything except trace, debug and info messages.
     * @type {number}
     * @deprecated
     */
    TIME = 4,
    /**
     * Logs everything except trace, debug, info and time messages.
     * @type {number}
     */
    WARN = 5,
    /**
     * Logs everything except trace, debug, info, time and warn messages.
     * @type {number}
     */
    ERROR = 8,
    /**
     * Turn off all logging.
     * @type {number}
     */
    OFF = 99
}
export type LogMethods = 'trace' | 'debug' | 'info' | 'time' | 'warn' | 'timeEnd' | 'error';
export declare class ILogger extends EventEmitter {
    TRACE: LogLevel.TRACE;
    DEBUG: LogLevel.DEBUG;
    INFO: LogLevel.INFO;
    TIME: LogLevel.TIME;
    WARN: LogLevel.WARN;
    ERROR: LogLevel.ERROR;
    OFF: LogLevel.OFF;
    level: LogLevel;
    constructor();
    /**
     * Logs a message at the trace level.
     * @param {unknown[]} values
     */
    trace(...values: readonly unknown[]): void;
    /**
     * Logs a message at the debug level.
     * @param {unknown[]} values
     */
    debug(...values: readonly unknown[]): void;
    /**
     * Logs a message at the info level.
     * @param {unknown[]} values
     */
    info(...values: readonly unknown[]): void;
    /**
     * Logs a message at the time level.
     * @param {unknown[]} values
     * @deprecated
     */
    time(val: string): void;
    /**
     * Logs a message at the time level.
     * @param {unknown[]} values
     * @deprecated
     */
    timeEnd(val: string): void;
    /**
     * Logs a message at the warn level.
     * @param {unknown[]} values
     */
    warn(...values: readonly unknown[]): void;
    /**
     * Logs a message at the error level.
     * @param {unknown[]} values
     */
    error(...values: readonly unknown[]): void;
    /**
     * Logs a message at the given level.
     * @param {LogLevel} level
     * @param {unknown[]} values
     * @returns {void}
     */
    invoke(level: LogLevel, ...values: readonly unknown[]): void;
    /**
     * Logs a time message at the given level.
     * @param {LogLevel} level
     * @param {unknown[]} values
     * @param {'start' | 'stop'} type
     * @returns {void}
     */
    invokeTime(level: LogLevel, val: string, type: 'start' | 'stop'): void;
    /**
     * Sets the log level.
     * @param {LogLevel} level
     * @returns {void}
     */
    setLevel(level: LogLevel): void;
    /**
     * Gets the log level.
     * @returns {LogLevel}
     */
    getLevel(): LogLevel;
    /**
     * Checks if the given level is enabled.
     * @param {LogLevel} level
     * @returns {boolean}
     */
    enabledFor(level: LogLevel): boolean;
    /**
     * @deprecated
     */
    useDefaults(): void;
    /**
     * @deprecated
     */
    setHandler(): void;
    /**
     * @deprecated
     */
    get(): void;
    /**
     * @deprecated
     */
    createDefaultHandler(): void;
    protected readonly LevelMethods: Map<LogLevel, LogMethods>;
}
export declare const Logger: ILogger;
//# sourceMappingURL=Logger.d.ts.map