declare const _subscriptions: unique symbol;
declare const _oneTimeEvents: unique symbol;
/**
 * Tipo para o callback de uma inscrição de evento.
 */
export type SubscriptionCallback<T extends Array<any> = any[]> = ((...arg: T) => void) & {};
/**
 * Interface para o manipulador de eventos retornado pelo método `on`.
 */
export interface EventHandler {
    /** Interrompe e remove o ouvinte de evento. */
    stop: () => void;
    remove: () => void;
}
/**
 * Tipo para os parâmetros dos listeners de eventos.
 */
export type EventsListenersParameters<T extends Record<any, (...arg: any[]) => void> = Record<any, (...arg: any[]) => void>> = {
    [key in keyof T]: Parameters<T[key]>;
} & {};
/**
 * Tipo para os listeners de eventos.
 */
export type EventsListeners<T extends Record<any, any[]> = Record<any, any[]>> = {
    [key in keyof T]: T[key];
} & {};
/**
 * Classe EventEmitter para gerenciar e emitir eventos personalizados.
 */
export declare class EventEmitter<T extends EventsListeners | EventsListenersParameters = any> {
    private [_subscriptions];
    private [_oneTimeEvents];
    private _ready;
    /**
     * Cria uma nova instância de EventEmitter.
     */
    constructor();
    /**
     * Aguarda o emissor estar pronto para então executar um callback.
     * @param {() => R | Promise<R>} [callback] - Função a ser executada quando o emissor estiver pronto.
     * @returns {Promise<R>} Uma Promise que resolve com o resultado do callback.
     *
     * @example
     * const emitter = new EventEmitter();
     *
     * emitter.ready(() => {
     *     console.log("O emissor está pronto!");
     * });
     *
     * emitter.prepared = true;
     * // Saída: O emissor está pronto!
     */
    ready<R = never>(callback?: () => R | Promise<R>): Promise<R>;
    /**
     * Verifica se o emissor está preparado.
     * @returns {boolean} `true` se o emissor estiver pronto, caso contrário `false`.
     *
     * @example
     * const emitter = new EventEmitter();
     *
     * emitter.ready(() => {
     *      console.log("O emissor está pronto!");
     * });
     *
     * console.log(emitter.prepared);
     * // Saída: false
     *
     * emitter.prepared = true;
     * console.log(emitter.prepared);
     * // Saída: true
     */
    get prepared(): boolean;
    /**
     * Property to set the emitter as prepared
     * @param {boolean} value - Define o estado de preparação do emissor.
     *
     * @example
     * const emitter = new EventEmitter();
     *
     * emitter.ready(() => {
     *      console.log("O emissor está pronto!");
     * });
     *
     * emitter.prepared = true;
     * // Saída: O emissor está pronto!
     */
    set prepared(value: boolean);
    /**
     * Define o emissor como preparado.
     * @param {boolean} [value=true] - O estado de preparação a ser definido.
     * @returns {void}
     *
     * @example
     * const emitter = new EventEmitter();
     *
     * emitter.ready(() => {
     *      console.log("O emissor está pronto!");
     * });
     *
     * emitter.prepare();
     * // Saída: O emissor está pronto!
     */
    prepare(value?: boolean): void;
    /**
     * Limpa todos os ouvintes de eventos.
     * @returns {void}
     * @example
     * const emitter = new EventEmitter();
     * emitter.clearEvents();
     * // Todos os eventos foram removidos.
     */
    clearEvents(): void;
    /**
     * Adiciona um ouvinte para um evento específico.
     * @param {K} event - O nome do evento para o qual se inscrever.
     * @param {SubscriptionCallback<T[K]>} callback - A função a ser executada quando o evento for emitido.
     * @returns {EventHandler} Um objeto com um método `remove()` para cancelar a inscrição.
     * @example
     * const emitter = new EventEmitter<{
     *      saudacao: [nome: string];
     *      despedida: [nome: string];
     * }>();
     *
     * emitter.on("saudacao", (nome) => {
     *      console.log(`Olá, ${nome}!`);
     * });
     *
     * emitter.emit("saudacao", "Alice");
     * // Saída: Olá, Alice!
     */
    on<K extends keyof T>(event: K, callback: SubscriptionCallback<T[K]>): EventHandler;
    /**
     * Remove um ouvinte de um evento específico.
     * @param {K} event - O nome do evento.
     * @param {SubscriptionCallback<T[K]>} [callback] - O callback específico a ser removido. Se omitido, remove todos os ouvintes para o evento.
     * @returns {EventEmitter<T>} A própria instância do EventEmitter.
     *
     * @example
     * const emitter = new EventEmitter<{
     *      saudacao: [nome: string];
     * }>();
     *
     * const ouvinte = (nome) => {
     *      console.log(`Olá, ${nome}!`);
     * }
     *
     * emitter.on("saudacao", ouvinte);
     * emitter.off("saudacao", ouvinte);
     *
     * emitter.emit("saudacao", "Alice");
     * // Nenhuma saída
     */
    off<K extends keyof T>(event: K, callback?: SubscriptionCallback<T[K]>): EventEmitter<T>;
    /**
     * Adiciona um ouvinte que será executado apenas uma vez e depois removido.
     * @param {K} event - O nome do evento.
     * @param {(...args: T[K]) => R} [callback] - A função a ser executada.
     * @returns {Promise<R>} Uma Promise que resolve com o valor de retorno do callback quando o evento é emitido.
     * @example
     * const emitter = new EventEmitter<{
     *      greet: [name: string];
     *      farewell: [name: string];
     * }>();
     *
     * emitter.once("greet", (name) => {
     *      console.log(`Hello, ${name}!`);
     * });
     *
     * emitter.emit("greet", "Alice");
     * // Saída: Hello, Alice!
     */
    once<K extends keyof T, R = any>(event: K, callback?: (...args: T[K]) => R): Promise<typeof callback extends undefined ? undefined : R>;
    /**
     * Remove um ouvinte de uso único (`once`).
     * @param {K} event - O nome do evento.
     * @param {(...args: T[K]) => any} [callback] - O callback específico a ser removido.
     * @returns {EventEmitter<T>} A própria instância do EventEmitter.
     *
     * @example
     * const emitter = new EventEmitter<{
     *      greet: [name: string];
     *      farewell: [name: string];
     * }>();
     *
     * const ouvinte = (nome) => {
     *      console.log(`Olá, ${nome}!`);
     * }
     *
     * emitter.once("greet", ouvinte);
     * emitter.offOnce("greet", ouvinte);
     */
    offOnce<K extends keyof T>(event: K, callback?: (...args: T[K]) => any): EventEmitter<T>;
    /**
     * Emite um evento, acionando todos os seus ouvintes.
     * @param {K} event - O nome do evento a ser emitido.
     * @param {T[K]} arg - Argumentos para passar aos ouvintes do evento.
     * @returns {EventEmitter<T>} A própria instância do EventEmitter.
     * @example
     * const emitter = new EventEmitter<{
     *      saudacao: [nome: string];
     * }>();
     *
     * emitter.on("saudacao", (nome) => {
     *      console.log(`Olá, ${nome}!`);
     * });
     *
     * emitter.emit("saudacao", "Alice");
     * // Saída: Olá, Alice!
     */
    emit<K extends keyof T>(event: K, ...arg: T[K]): EventEmitter<T>;
    /**
     * Emite um evento que só pode ser disparado uma única vez.
     * Qualquer ouvinte adicionado posteriormente para este evento será executado imediatamente.
     * @param {K} event - O nome do evento a ser emitido.
     * @param {T[K]} arg - Argumentos para passar aos ouvintes.
     * @returns {EventEmitter<T>} A própria instância do EventEmitter.
     * @example
     * const emitter = new EventEmitter<{
     *      configuracao: [config: object];
     * }>();
     *
     * emitter.emitOnce("configuracao", { tema: "dark" });
     *
     * // Este ouvinte será chamado imediatamente porque 'configuracao' já foi emitido.
     * emitter.on("configuracao", (config) => {
     *      console.log(`Configuração recebida:`, config);
     * });
     * // Saída: Configuração recebida: { tema: 'dark' }
     */
    emitOnce<K extends keyof T>(event: K, ...arg: T[K]): EventEmitter<T>;
    /**
     * Redireciona eventos de um emissor para outro.
     * @param {K} event - O evento a ser redirecionado.
     * @param {EventEmitter<T>} eventEmitter - O emissor de destino.
     * @returns {EventHandler} Um objeto com um método `remove()` para parar o redirecionamento.
     * @example
     * const emitter = new EventEmitter<{
     *      mensagem: [texto: string];
     * }>();
     *
     * const anotherEmitter = new EventEmitter<{
     *      mensagem: [texto: string];
     * }>();
     *
     * emitter.pipe("mensagem", anotherEmitter);
     *
     * anotherEmitter.on("mensagem", (texto) => {
     *      console.log(`Outro emissor recebeu: ${texto}`);
     * });
     *
     * emitter.emit("mensagem", "Olá mundo!");
     * // Saída: Outro emissor recebeu: Olá mundo!
     */
    pipe<K extends keyof T>(event: K, eventEmitter: EventEmitter<T>): EventHandler;
    /**
     * Redireciona um evento de um emissor para outro, apenas uma vez.
     * @param {K} event - O evento a ser redirecionado.
     * @param {EventEmitter<T>} eventEmitter - O emissor de destino.
     * @returns {Promise<void>} Uma Promise que resolve quando o evento é redirecionado.
     * @example
     * const emitter = new EventEmitter<{
     *      login: [usuario: string];
     * }>();
     *
     * const anotherEmitter = new EventEmitter<{
     *      login: [usuario: string];
     * }>();
     *
     * emitter.pipeOnce("login", anotherEmitter);
     *
     * anotherEmitter.on("login", (usuario) => {
     *      console.log(`${usuario} logado no outro emissor.`);
     * });
     *
     * emitter.emit("login", "Alice");
     * // Saída: Alice logado no outro emissor.
     */
    pipeOnce<K extends keyof T>(event: K, eventEmitter: EventEmitter<T>): Promise<void>;
}
export {};
//# sourceMappingURL=index.d.ts.map