/**
* 一个简单的事件触发器
*/
interface FlexLiteEvents {
}
interface LiteEventSubscribeOptions {
    objectify?: boolean;
    count?: number;
}
interface LiteEventOptions {
    ignoreError?: boolean;
}
interface LiteEventListener<Message = any> {
    (message: Message): void;
}
type ForEachLiteEventListenerCallback<Events, Message> = ({ event, listenerId, listener, count, eventListeners }: {
    event: Events;
    listenerId: number;
    listener: LiteEventListener<Message>;
    count: number;
    eventListeners: LiteEventListenerRegistry<Message>;
}) => boolean | void;
interface LiteEventSubscriber {
    off(): void;
}
type LiteEventListenerRegistry<M> = Map<number, [LiteEventListener<M>, number]>;
type LiteListenerRegistry<E, M> = Map<E, LiteEventListenerRegistry<M>>;
declare class LiteEvent<Events extends FlexLiteEvents = Record<string, any>, EventNames extends keyof Events = keyof Events, Message = any> {
    private _listeners;
    private _lastMessage;
    static listenerSeqId: number;
    options: Required<LiteEventOptions>;
    constructor(options?: LiteEventOptions);
    get listeners(): LiteListenerRegistry<EventNames, Message>;
    /**
     * 订阅事件并返回一个事件订阅ID
     *
     * @param event
     * @param callback
     * @param options
     * @returns
     */
    on<T extends EventNames>(event: T, callback: LiteEventListener<Events[T]>, options?: LiteEventSubscribeOptions): LiteEventSubscriber | number;
    on(event: '*', callback: LiteEventListener<Message>, options?: LiteEventSubscribeOptions): LiteEventSubscriber | number;
    onAny(callback: LiteEventListener<Message>, options?: LiteEventSubscribeOptions): LiteEventSubscriber | number;
    /**
     * 如果事件已经有最近触发时保留的数据，则立即触发事件将最近的数据传递给侦听器
     * @param event
     */
    private _emitRetainEvent;
    /**
     * 只订阅一次事件
     * @param event
     * @param callback
     * @param options
     * @returns
     */
    once<T extends EventNames>(event: T, callback: LiteEventListener<Events[T]>, options?: LiteEventSubscribeOptions): number | LiteEventSubscriber;
    /**
      * 遍历所有侦听器
      *   {"<事件名称>":{<listenerId>:[Callback,<侦听次数>]}}
      * @param callback  ={}
      */
    private _forEachListeners;
    /**
     * 遍历符合event事件的侦听器
     *
     * forEachEventListeners(event,callback)
     *
     * @param event         事件名称
     * @param callback
     * @returns
     */
    private _forEachEventListeners;
    /**
     * 注销订阅
     *
     * - 通过listenerId进行退订
     * - 直接指定一个callback并且callback严格相等
     * - 具备同一样原型链的callback的均退订
     *
     *  let listenerId = emitter.on(event,callback)
     *
     *  emitter.off(listenerId)              // 精确退订指定的订阅，需要自行保存订阅Id
     *  emitter.off(callback)                // 所有callback均会退订
     *  emitter.off(event,callback)          // 退订指定事件的callback均会退订
     *
     * @param event
     * @param callback
     * @returns
     */
    off(listener: LiteEventListener<Message>): void;
    off(listenerId: number): void;
    off(event: EventNames, listener: LiteEventListener<any>): void;
    /**
     * 等待某个事件触发后返回
     * @param event  事件名称
     */
    waitFor(event: EventNames, timeout?: number): Promise<Message>;
    offAll(event?: EventNames): void;
    /**
     * 执行侦听器函数
     *
     * @param listenerId  侦听器ID
     * @param listeners   事件侦听器列表
     * @param message
     * @returns
     */
    private _executeListener;
    private _executeListeners;
    /**
     * 触发事件
     * @param event
     * @param message
     */
    emit<T extends EventNames>(event: T, message?: Events[T], retain?: boolean): any[];
    emitAsync<T extends EventNames>(event: T, message?: Events[T], retain?: boolean): Promise<PromiseSettledResult<any>[]>;
}

export { type FlexLiteEvents, type ForEachLiteEventListenerCallback, LiteEvent, type LiteEventListener, type LiteEventListenerRegistry, type LiteEventOptions, type LiteEventSubscribeOptions, type LiteEventSubscriber, type LiteListenerRegistry };