type ListenerFunction<EventTypeMap extends object, T extends keyof EventTypeMap> = (arg: EventTypeMap[T]) => void | PromiseLike<void>;
/**
 * Payload emitted when a listener throws or rejects during {@link EventHub.emit}.
 * Subscribe to the `onListenerError` event to receive these.
 */
export type ListenerErrorPayload = {
    /** The event name that was being emitted when the error occurred */
    event: string | number | symbol;
    /** The error thrown or rejected by the listener */
    error: unknown;
};
/**
 * Typed pub/sub. Listener errors (sync throws and async rejections) are
 * caught automatically: if `onListenerError` listeners are registered they
 * receive the error, otherwise it is logged via `console.error`. One
 * listener throwing does not prevent the remaining listeners from running.
 *
 * @typeParam EventTypeMap - object whose keys are event names and values are
 *   the payload types
 * @example
 * ```ts
 * type MyEvents = {
 *   userLoggedIn: { userId: string }
 *   userLoggedOut: { userId: string }
 *   dataUpdated: { items: string[] }
 *   onListenerError: ListenerErrorPayload
 * }
 *
 * const hub = new EventHub<MyEvents>()
 *
 * // Subscribe to events
 * hub.subscribe('userLoggedIn', (event) => {
 *   console.log('User logged in:', event.userId)
 * })
 *
 * // Handle listener errors
 * hub.subscribe('onListenerError', ({ event, error }) => {
 *   console.error(`Listener for "${String(event)}" failed:`, error)
 * })
 *
 * // Emit events
 * hub.emit('userLoggedIn', { userId: '123' })
 *
 * // Clean up when done
 * hub[Symbol.dispose]()
 * ```
 */
export declare class EventHub<EventTypeMap extends object> implements Disposable {
    #private;
    addListener<TEvent extends keyof EventTypeMap>(event: TEvent, listener: ListenerFunction<EventTypeMap, TEvent>): void;
    removeListener<TEvent extends keyof EventTypeMap>(event: TEvent, listener: ListenerFunction<EventTypeMap, TEvent>): void;
    /**
     * Subscribes `listener` to `event` and returns a `Disposable` that removes
     * the listener when disposed — preferred over the `addListener` /
     * `removeListener` pair for `using` / `useDisposable` integration.
     */
    subscribe<TEvent extends keyof EventTypeMap>(event: TEvent, listener: ListenerFunction<EventTypeMap, TEvent>): Disposable;
    emit<TEvent extends keyof EventTypeMap>(event: TEvent, arg: EventTypeMap[TEvent]): void;
    [Symbol.dispose](): void;
}
export {};
//# sourceMappingURL=event-hub.d.ts.map