import type { Client, WorkerClient } from '../client';
import type { BaseClient } from '../client/base';
import { type PluginOrderedContribution } from '../client/plugins/order';
import type { UsingClient } from '../commands';
import type { FileLoaded } from '../commands/handler';
import { type Awaitable, BaseHandler, type CamelCase, type MakeRequired, type SnakeCase } from '../common';
import type { ClientEvents } from '../events/hooks';
import { type GatewayDispatchPayload } from '../types';
import type { ClientEvent, ClientNameEvents, CustomEvents, CustomEventsKeys, EventContext } from './event';
export type EventValue = MakeRequired<ClientEvent, '__filePath'> & {
    fired?: boolean;
};
export type GatewayEvents = Uppercase<SnakeCase<keyof ClientEvents>>;
export type ResolveEventParams<T extends ClientNameEvents | CustomEventsKeys | GatewayEvents> = T extends CustomEventsKeys ? [...Parameters<CustomEvents[T]>, UsingClient] : T extends GatewayEvents ? EventContext<{
    data: {
        name: CamelCase<T>;
    };
}> : T extends ClientNameEvents ? EventContext<{
    data: {
        name: T;
    };
}> : never;
export type ResolveEventRunParams<T extends ClientNameEvents | CustomEventsKeys | GatewayEvents> = T extends CustomEventsKeys ? Parameters<CustomEvents[T]> : T extends GatewayEvents ? EventContext<{
    data: {
        name: CamelCase<T>;
    };
}> : T extends ClientNameEvents ? EventContext<{
    data: {
        name: T;
    };
}> : never;
export type EventValues = {
    [K in CustomEventsKeys | GatewayEvents]: Omit<EventValue, 'run'> & {
        run(...args: ResolveEventRunParams<K>): Awaitable<unknown>;
    };
};
export interface CustomEventRunner {
    emit<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Awaitable<void>;
    runCustom<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Awaitable<void>;
}
type PluginEventListener = PluginOrderedContribution & {
    record: {
        plugin: {
            name: string;
            instanceId?: string;
        };
        index: number;
    };
    name: string;
    handler: (...args: unknown[]) => unknown;
    active: boolean;
    once?: boolean;
    fired?: boolean;
};
type PluginAnyEventListener = PluginOrderedContribution & {
    record: {
        plugin: {
            name: string;
            instanceId?: string;
        };
        index: number;
    };
    handler: (name: string, ...args: unknown[]) => unknown;
    active: boolean;
};
type ClientWithPluginRegistry = BaseClient;
export declare class CustomEventHandler extends BaseHandler implements CustomEventRunner {
    protected client: ClientWithPluginRegistry;
    constructor(client: ClientWithPluginRegistry);
    onFail: (event: GatewayEvents | CustomEventsKeys | string, err: unknown) => void;
    values: Partial<EventValues>;
    emit<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Promise<void>;
    runCustom<T extends CustomEventsKeys>(name: T, ...args: ResolveEventRunParams<T>): Promise<void>;
    protected getPluginListeners(name: string): import("../client/plugins/registry").PluginEventContribution[];
    protected getPluginAnyListeners(): import("../client/plugins/registry").PluginAnyEventContribution[];
    protected getPluginErrorListeners(): import("../client/plugins/registry").PluginEventErrorContribution[];
    protected runCollectors(name: string, args: unknown): unknown;
    protected createPluginListenerTask(name: string, listeners: readonly PluginEventListener[], anyListeners: readonly PluginAnyEventListener[], args: readonly unknown[]): Promise<void> | undefined;
    protected settleEventTasks(name: GatewayEvents | CustomEventsKeys | string, tasks: readonly Promise<unknown>[]): Promise<void>;
    protected reportEventFailure(name: GatewayEvents | CustomEventsKeys | string, error: unknown): Promise<void>;
}
export declare class EventHandler extends CustomEventHandler {
    protected client: Client | WorkerClient;
    constructor(client: Client | WorkerClient);
    filter: (path: string) => boolean;
    discordEvents: ClientNameEvents[];
    set(events: ClientEvent[]): void;
    load(eventsDir: string): Promise<void>;
    execute(raw: GatewayDispatchPayload, client: Client<true> | WorkerClient<true>, shardId: number): Promise<void>;
    runEvent(name: GatewayEvents, client: Client | WorkerClient, packet: unknown, shardId: number, runCache?: boolean): Promise<void>;
    reload(name: GatewayEvents | CustomEventsKeys): Promise<any>;
    reloadAll(stopIfFail?: boolean): Promise<void>;
    onFile(file: FileLoaded<ClientEvent>): ClientEvent[] | undefined;
    callback: (file: ClientEvent) => ClientEvent | false;
}
export {};