declare type EventType = string | symbol;
declare type Handler<T = unknown> = (event: T) => void;
declare type EventHandlerList<Events> = Array<Handler<Events[keyof Events]>>;
export declare type EventHandler<Events, Key extends keyof Events> = (event: Events[Key]) => void;
export declare class Emitter<Events extends Record<EventType, unknown>> {
    /**
     * A Map of event names to registered handler functions.
     */
    all: Map<keyof Events, EventHandlerList<Events>>;
    /**
     * Register an event handler for the given type.
     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
     * @param {Function} handler Function to call in response to given event
     */
    on<Key extends keyof Events>(type: Key, handler: EventHandler<Events, Key>): void;
    /**
     * Register an event handler for given type, to run once
     * @param {string|symbol} type Type for the event to listen for
     * @param {Function} handler Function to call in response to given event
     */
    once<Key extends keyof Events>(type: Key, handler: EventHandler<Events, Key>): void;
    /**
     * Remove an event handler for the given type.
     * If `handler` is omitted, all handlers of the given type are removed.
     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
     * @param {Function} [handler] Handler function to remove
     */
    off<Key extends keyof Events>(type: Key, handler?: EventHandler<Events, Key>): void;
    /**
     * Invoke all handlers for the given type.
     *
     * @param {string|symbol} type The event type to invoke
     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
     */
    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]): void;
}
export {};