/**
 * Valid event tyes.
 */
type EventType = string | symbol;
/**
 * Generic event map used for type checking.
 */
type GenericEventMap = Record<EventType, unknown>;
/**
 * Event handler function. Transforms tuples into rest parameters.
 * @internal
 */
type Handler<Payload> = (...payload: ToTuple<Payload>) => void;
/**
 * Convenience type for a list of event handlers.
 * @internal
 */
type EventHandlerList<Payload = unknown> = Handler<Payload>[];
/**
 * Convenience type for a list of wildcard event handlers.
 * @internal
 */
type WildCardEventHandlerList<EventMap extends GenericEventMap> = WildcardHandler<EventMap>[];
/**
 * Map of event names to registered handler functions.
 */
type EventHandlerMap<EventMap extends GenericEventMap> = Map<keyof EventMap | '*', GenericEventHandler<EventMap>[]>;
/**
 * Event handler function for a specific event type.
 */
type GenericEventHandler<EventMap extends GenericEventMap> = Handler<EventMap[keyof EventMap]> | WildcardHandler<EventMap>;
/**
 * Convenience type for the returned function of `on`.
 * @internal
 */
type RemoveEventListener = () => void;
/**
 * Event handler function for the `'*'` event type.
 * @internal
 */
type WildcardHandler<EventMap extends GenericEventMap> = (...args: {
    [Event in keyof EventMap]: [type: Event, payloads: ToTuple<EventMap[Event]>];
}[keyof EventMap]) => void;
/**
 * Transforms a non tuple into a tuple with the value but keeps tuples as is.
 * @internal
 */
type ToTuple<T> = T extends [unknown, ...unknown[]] | [] ? T : [T];
/**
 * Event emitter class.
 */
declare class EventEmitter<Events extends GenericEventMap> {
    /**
     * A Map of event names to registered handler functions.
     */
    all: EventHandlerMap<Events>;
    constructor(all?: EventHandlerMap<Events>);
    /**
     * Register an event handler for the given type.
     * @param type Type of event to listen for, or `'*'` for all events
     * @param handler Function to call in response to given event
     */
    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): RemoveEventListener;
    /**
     * Register an event handler for all events.
     * @param type `'*'`
     * @param handler Function to call in response to given event
     */
    on(type: '*', handler: WildcardHandler<Events>): RemoveEventListener;
    /**
     * Remove an event handler for the given type.
     * If `handler` is omitted, all handlers of the given type are removed.
     * @param type Type of event to unregister `handler` from, or `'*'`
     * @param handler Handler function to remove
     */
    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
    off(type: '*', handler?: WildcardHandler<Events>): void;
    /**
     * Remove all event handlers.
     */
    off(): void;
    /**
     * Invoke all handlers for the given type.
     * If present, `'*'` handlers are invoked after type-matched handlers.
     *
     * Note: Manually firing `'*'` handlers is not supported.
     *
     * @param type The event type to invoke
     * @param payload Any value to each handler
     */
    emit<Key extends keyof Events>(type: Key, ...payload: ToTuple<Events[Key]>): void;
}

export { EventEmitter, type EventHandlerMap, type EventType, type GenericEventHandler, type GenericEventMap, type EventHandlerList as _EventHandlerList, type Handler as _Handler, type RemoveEventListener as _RemoveEventListener, type ToTuple as _ToTuple, type WildCardEventHandlerList as _WildCardEventHandlerList, type WildcardHandler as _WildcardHandler };