eventemitter2

constructor(options?: ConstructorOptions);

static defaultMaxListeners: number;

addListener: (event: event | eventNS, listener: ListenerFn) => this | Listener;

emit: (event: event | eventNS, ...values: any[]) => boolean;

emitAsync: (event: event | eventNS, ...values: any[]) => Promise<any[]>;

eventNames: (nsAsArray?: boolean) => (event | eventNS)[];

getMaxListeners: () => number;

hasListeners: (event?: String) => Boolean;

listenerCount: (event?: event | eventNS) => number;

listeners: (event?: event | eventNS) => ListenerFn[];

listenersAny: () => ListenerFn[];

listenTo: {
    (
        target: GeneralEventEmitter,
        events: event | eventNS,
        options?: ListenToOptions
    ): this;
    (
        target: GeneralEventEmitter,
        events: event[],
        options?: ListenToOptions
    ): this;
    (
        target: GeneralEventEmitter,
        events: Object,
        options?: ListenToOptions
    ): this;
};

many: (
    event: event | eventNS,
    timesToListen: number,
    listener: ListenerFn,
    options?: boolean | OnOptions
) => this | Listener;

off: (event: event | eventNS, listener: ListenerFn) => this;

offAny: (listener: ListenerFn) => this;

on: (
    event: event | eventNS,
    listener: ListenerFn,
    options?: boolean | OnOptions
) => this | Listener;

onAny: (listener: EventAndListener) => this;

static once: (
    emitter: EventEmitter2,
    event: event | eventNS,
    options?: OnceOptions
) => CancelablePromise<any[]>;

prependAny: (listener: EventAndListener) => this;

prependListener: (
    event: event | eventNS,
    listener: ListenerFn,
    options?: boolean | OnOptions
) => this | Listener;

prependMany: (
    event: event | eventNS,
    timesToListen: number,
    listener: ListenerFn,
    options?: boolean | OnOptions
) => this | Listener;

prependOnceListener: (
    event: event | eventNS,
    listener: ListenerFn,
    options?: boolean | OnOptions
) => this | Listener;

removeAllListeners: (event?: event | eventNS) => this;

removeListener: (event: event | eventNS, listener: ListenerFn) => this;

setMaxListeners: (n: number) => void;

stopListeningTo: (
    target?: GeneralEventEmitter,
    event?: event | eventNS
) => Boolean;

waitFor: {
    (event: event | eventNS, timeout?: number): CancelablePromise<any[]>;
    (
        event: string | symbol | event[],
        filter?: WaitForFilter
    ): CancelablePromise<any[]>;
    (
        event: string | symbol | event[],
        options?: WaitForOptions
    ): CancelablePromise<any[]>;
};

cancel: (reason: string) => undefined;

delimiter?: string;

ignoreErrors?: boolean;

maxListeners?: number;

newListener?: boolean;

removeListener?: boolean;

verboseMemoryLeak?: boolean;

wildcard?: boolean;

(event: string | string[], ...values: any[]): void;

addEventListener: (event: event, handler: ListenerFn) => this;

addListener: (event: event, handler: ListenerFn) => this;

off: (event: event, handler: ListenerFn) => this;

on: (event: event, handler: ListenerFn) => this;

removeEventListener: (event: event, handler: ListenerFn) => this;

removeListener: (event: event, handler: ListenerFn) => this;

emitter: EventEmitter2;

event: event | eventNS;

listener: ListenerFn;

off: () => this;

(...values: any[]): void;

off?: { (event: event | eventNS, handler: ListenerFn): void };

on?: { (event: event | eventNS, handler: ListenerFn): void };

reducers: Function | Object;

overload: boolean;

Promise: Function;

timeout: number;

async?: boolean;

nextTick?: boolean;

objectify?: boolean;

promisify?: boolean;

(...values: any[]): boolean;

filter: WaitForFilter;

handleError: boolean;

overload: boolean;

Promise: Function;

timeout: number;