import events from 'events';
import { AsyncOrSync } from 'ts-essentials';
/**
 * Asynchronously sets up an emitter, returning it. If an error occurs during
 * setup, it will be emitted on the emitter. Note that the setup will always run
 * after the emitter is returned.
 */
export declare function withEmitter<E extends events.EventEmitter>(ee: E, fn: (ee: E) => AsyncOrSync<void>): E;
/** Generic event lister. */
export type EventListener = (...args: any) => void;
export type EventListenersFor<O> = {
    readonly [E in keyof O]: EventListener;
};
type EventName = string | symbol;
export interface EventListeners {
    readonly [E: EventName]: EventListener;
}
type EventNamesFor<O extends EventListenersFor<O>> = (keyof O & EventName) | 'error';
type InternalEventNames = typeof events.errorMonitor | 'newListener' | 'removeListener';
type EventListenerFor<O extends EventListenersFor<O>, E extends EventNamesFor<O> | InternalEventNames> = E extends keyof O ? O[E] : E extends 'error' | typeof events.errorMonitor ? (err: unknown) => void : E extends 'newListener' | 'removeListener' ? (name: EventName, fn: EventListener) => void : never;
export interface EventProducer<O extends EventListenersFor<O>> {
    emit<E extends EventNamesFor<O>>(eventName: E, ...args: Parameters<EventListenerFor<O, E>>): boolean;
    emit(eventName: EventNamesFor<O>, arg: never): boolean;
}
export interface EventConsumer<O extends EventListenersFor<O>> {
    addListener<E extends EventNamesFor<O> | InternalEventNames>(event: E, listener: EventListenerFor<O, E>): this;
    prependListener<E extends EventNamesFor<O> | InternalEventNames>(event: E, listener: EventListenerFor<O, E>): this;
    prependOnceListener<E extends EventNamesFor<O> | InternalEventNames>(event: E, listener: EventListenerFor<O, E>): this;
    removeListener<E extends EventNamesFor<O> | InternalEventNames>(event: E, listener: EventListenerFor<O, E>): this;
    removeAllListeners(event?: EventNamesFor<O> | InternalEventNames): this;
    once<E extends EventNamesFor<O> | InternalEventNames>(eventName: E, listener: EventListenerFor<O, E>): this;
    on<E extends EventNamesFor<O> | InternalEventNames>(eventName: E, listener: EventListenerFor<O, E>): this;
    off<E extends EventNamesFor<O> | InternalEventNames>(eventName: E, listener: EventListenerFor<O, E>): this;
    listenerCount(type: EventNamesFor<O>): number;
    listeners<E extends EventNamesFor<O> | InternalEventNames>(type: E): Function[];
    rawListeners<E extends EventNamesFor<O> | InternalEventNames>(type: E): Function[];
    getMaxListeners(): number;
    setMaxListeners(n: number): this;
}
/**
 * An event emitter with configurable specific type for event names and
 * listeners. Note that an error listener is implicitly added (with `unknown`
 * error type).
 *
 * The simplest way to use it is with a vanilla underlying event emitter:
 *
 *  ```
 *  interface MyListeners {
 *    foo: (n: number) => void;
 *  }
 *
 *  const ee = typedEmitter<MyListeners>();
 *  ```
 */
export interface TypedEmitter<O extends EventListenersFor<O>> extends EventProducer<O>, EventConsumer<O> {
    eventNames(): EventName[];
}
export declare const TypedEmitter: new <O extends EventListenersFor<O>>() => TypedEmitter<O>;
export interface EventEmitterOptions {
    readonly captureRejections?: boolean;
}
/** Returns a typed emitter backed by standard `events.EventEmitter`. */
export declare function typedEmitter<O extends EventListenersFor<O>>(opts?: EventEmitterOptions): TypedEmitter<O>;
/**
 * Returns a typed event consumer. Any errors thrown during setup (synchronous
 * or not) will be emitted as `'error'` events on the next tick.
 */
export declare function withTypedEmitter<O extends EventListenersFor<O>>(fn: (ee: TypedEmitter<O>) => AsyncOrSync<void>): EventConsumer<O>;
/**
 * Iterates on emitted events of the given name until aborted. This is similar
 * to `events.on` but does not throw when aborted, the iterator simply returns.
 * Note that all listeners will be removed from the target when this iterator
 * returns.
 */
export declare function yieldEvents<O extends EventListenersFor<O>, E extends keyof O & string>(ee: TypedEmitter<O> | EventConsumer<O>, name: E, opts?: YieldEventsOptions<keyof O>): AsyncIterable<Parameters<O[E]>>;
export interface YieldEventsOptions<E = string> {
    readonly until?: E | ReadonlyArray<E>;
    readonly signal?: AbortSignal;
    readonly throwIfAborted?: boolean;
}
/**
 * Streams multiple events until the function's provided argument is called. If
 * the consumer does not have an `error` mapper, one will be automatically be
 * added which will cause the returned iterable to throw.
 *
 * Note that this since is implemented as a generator function, all setup logic
 * will only run once the returned value is used (iterated on, typically). This
 * means in particular that error handling logic will not be set up until then.
 */
export declare function mapEvents<O extends EventListenersFor<O>, V>(ee: EventConsumer<O>, fn: (exit: () => void) => EventMappersFor<O, V>): AsyncIterable<V>;
export type EventMappersFor<O extends EventListenersFor<O>, V> = {
    readonly [E in EventNamesFor<O>]?: (...args: Parameters<EventListenerFor<O, E>>) => AsyncOrSync<V>;
};
/** Waits for a single event. This is a typed version of `events.once`. */
export declare function waitForEvent<O extends EventListenersFor<O>, E extends keyof O & string>(ee: TypedEmitter<O> | EventConsumer<O>, name: E, opts?: {
    readonly signal?: AbortSignal;
}): Promise<Parameters<O[E]>>;
/**
 * Casts a subtype of event emitter to the base type. This is useful when
 * dealing with union types which otherwise return an error saying "This
 * expression is not callable ... none of those signatures are compatible".
 */
export declare function asEmitter<E extends events.EventEmitter>(ee: E): events.EventEmitter;
export {};