type EventArgs = [any] | [any?] | [];
type EventObjects = Record<string, EventArgs | EventEmitter.DataEvent<string, any, any>>;
type GetEventObjectTuple<Map extends EventObjects, K extends keyof Map, Target> = Map[K] extends [
    EventEmitter.DataEvent<any, any, any>
] ? [data: EventEmitter.DataEvent<K, Map[K][0]['data'], Target>] : Map[K] extends EventEmitter.DataEvent<any, any, any> ? [data: EventEmitter.DataEvent<K, Map[K]['data'], Target>] : [data: EventEmitter.DataEvent<K, Map[K] extends EventArgs ? Map[K][0] : unknown, Target>];
type ToArgs<Data> = IfExtends<Exclude<Data, undefined>, never, [
], IfExtends<Data, undefined, [Data?], [Data]>>;
type GetEventDataTuple<Map extends EventObjects, K extends keyof Map> = ToArgs<GetEventObjectTuple<Map, K, any>[0]['data']>;
type EventNames<T extends string | symbol | EventObjects> = T extends string | symbol ? T : keyof T;
type EmitArgs<EventTypes extends string | symbol | EventObjects, K extends EventNames<EventTypes>> = EventTypes extends EventObjects ? GetEventDataTuple<EventTypes, Extract<K, keyof EventTypes>> : [unknown?];
declare const optionsKey: unique symbol;
declare const eventsKey: unique symbol;
declare const setOptionsKey: unique symbol;
declare const getOptionsKey: unique symbol;
export declare class EventEmitter<EventTypes extends string | symbol | EventObjects, Target extends Pick<EventEmitter<EventTypes, Target>, 'on' | 'once' | 'off' | 'removeAllListeners' | 'emit'> = EventEmitter<EventTypes, any>> {
    static readonly symbols: {
        setOptions: symbol;
        getOptions: symbol;
    };
    private readonly [optionsKey];
    private readonly [eventsKey];
    constructor(options?: EventEmitter.Options);
    [getOptionsKey](): EventEmitter.Options;
    [setOptionsKey](options: Partial<EventEmitter.Options>): this;
    getEventListeners(): EventEmitter.EventListeners<EventTypes, Target>;
    getListenerCount<T extends EventNames<EventTypes>>(event?: T): number;
    on<T extends EventNames<EventTypes>>(event: T, fn: EventEmitter.EventListener<EventTypes, T, Target>, options?: EventEmitter.AddEventListenerOptions): this;
    once<T extends EventNames<EventTypes>>(event: T, fn: EventEmitter.EventListener<EventTypes, T, Target>): this;
    off<T extends EventNames<EventTypes>>(event: T, fn?: EventEmitter.EventListener<EventTypes, T, Target>): this;
    removeAllListeners(event?: EventNames<EventTypes>): this;
    removeAllListenersBut(...events: EventNames<EventTypes>[]): this;
    emit<T extends EventNames<EventTypes>>(event: T, ...args: EmitArgs<EventTypes, T>): boolean;
}
export declare namespace EventEmitter {
    export interface DataEvent<Type, Data, Target> {
        type: Type;
        data: Data;
        target: Target;
    }
    export type EventMap<Map extends EventObjects, Target> = {
        [P in keyof Map]: GetEventObjectTuple<Map, P, Target>[0];
    };
    type Listener<Args extends any[]> = (...args: Args) => void;
    export type EventListener<EventTypes extends string | symbol | EventObjects, K extends EventNames<EventTypes>, Target> = EventTypes extends EventObjects ? Listener<[event: EventMap<EventTypes, Target>[Extract<K, keyof EventTypes>]]> : Listener<[event: EventEmitter.DataEvent<EventTypes, unknown, Target>]>;
    export type EventListeners<EventTypes extends string | symbol | EventObjects, Target> = {
        [P in EventNames<EventTypes>]: EventListener<EventTypes, P, Target>[];
    };
    export interface Options {
        /** Defaults to `true`. */
        readonly ignoreListenerError?: boolean | undefined;
    }
    export interface AddEventListenerOptions {
        readonly once?: boolean | undefined;
    }
    export {};
}
export {};