/**
 * Custom event emitter implementation for use
 */
declare class EventEmitter<L extends ListenerSignature<L> = DefaultListener> {
    private _listeners;
    private _eventEmitterLogger;
    /**
     * Constructs instance
     */
    constructor();
    /**
     * Subscribes a listener to event
     * @param event Event to subscribe to
     * @param callback Listener function to subscribe
     */
    on<U extends EventEmitter.Event<L>>(event: U, callback: L[U]): void;
    /**
     * Unsubscribes a listener from event
     * @param event Event to unsubscribe from
     * @param callback Callback to unsubscribe
     */
    off<U extends EventEmitter.Event<L>>(event: U, callback: L[U]): void;
    /**
     * Subscribes a listener to event once
     * @param event Event to subscribe to
     * @param callback Listener function to subscribe
     * @param options Additional options
     */
    once<U extends EventEmitter.Event<L>>(event: U, callback: L[U], options?: EventEmitter.OnceOptions<L[U]>): void;
    /**
     * Emits an event
     * @param event Event to emit
     * @param data Event payload
     * @returns Promise resolving when all listeners calls completed. Usually async version is useful if listeners may
     * return promises and the call should wait for them. If one of listener rejects or throws an error, it will be
     * logged. Async listeners called all at once
     */
    emit<U extends EventEmitter.Event<L>>(event: U, ...args: Parameters<L[U]>): Promise<void>;
    /**
     * Returns subscribed events
     * @returns subscribed events
     */
    getSubscriptions(): EventEmitter.Event<L>[];
    /**
     * Returns subscribed event listeners
     * @param event Event
     * @returns Listeners
     */
    getListeners<U extends EventEmitter.Event<L>>(event: U): L[U][];
    /**
     * Returns whether has listeners on specific event
     * @param event Event
     * @returns Whether has listeners
     */
    hasListeners<U extends EventEmitter.Event<L>>(event: U): boolean;
    private _callListener;
}
declare namespace EventEmitter {
    /** Method options */
    type OnceOptions<Listener extends (...args: any[]) => any> = {
        /**
         * If specified, the listener will be called only if the callback returns true. Otherwise, the listener will wait
         * for the next matching call
         */
        ifArgs?: (...args: Parameters<Listener>) => boolean;
    };
    /** Infers event type of a listener */
    type Event<L extends ListenerSignature<L>> = Extract<keyof L, string>;
}
export default EventEmitter;
/**
 * Event emitter listener type
 */
export type ListenerSignature<Listeners> = {
    [EventName in keyof Listeners]: (...args: any[]) => any;
};
/**
 * Default event emitter listener type
 */
export type DefaultListener = {
    [k: string]: (...args: any[]) => any;
};