/** These apply to all hooks */
/**
 * @external
 */
export type StandardDefineHookOptions = {
    /** A set of tags for this hook - e.g., "direct" or "raw" - which can be provided as one of the options to all operations to filter which hooks run at a high level*/
    tags?: string[];
    /** The name - only useful for debugging purposes, e.g., with instrumentation */
    name?: string;
};
/**
 * @external
 */
export type StandardInvokeHookOptions<EM extends ChainedCallbackEventMap, K extends keyof EM = keyof EM> = {
    /** Filter the hooks to only run those which include one of these tags */
    includeTags?: string[];
    /** Filter the hooks to only run those which don't include one of these tags */
    excludeTags?: string[];
    /** A function to run to determine whether a hook should be ran or not */
    includeHook?: <HK extends K>(hookName: HK, hook: ChainedListenerCallback<EM, HK>, options?: EM[K]["options"]) => boolean;
    /** An abort signal to allow interuption of long running operations - particularly useful in the case of *Many operations with individual hooks */
    signal?: AbortSignal;
};
export type ChainedCallbackEntry<EMITARGS = any, CBARGS extends EMITARGS = EMITARGS> = {
    callbackArgs: CBARGS;
    returns: any;
    isPromise: boolean;
    emitArgs: EMITARGS;
    options: StandardDefineHookOptions;
    returnEmitName?: string | undefined;
};
export type ChainedCallbackEventMap = Record<string, ChainedCallbackEntry>;
type DefaultChainedCallbackEventMap = ChainedCallbackEventMap;
export type CallbackAndOptionsOfEm<EM extends ChainedCallbackEventMap, K extends keyof EM> = {
    options?: EM[K]["options"];
    listener: ChainedListenerCallback<EM, K>;
};
export type ChainedListenerCallback<EM extends ChainedCallbackEventMap, K extends keyof EM> = (EM[K]["callbackArgs"] extends object ? (...args: [EM[K]["callbackArgs"]]) => EM[K]["isPromise"] extends true ? EM[K]["returns"] | void | Promise<void | EM[K]["returns"]> : EM[K]["returns"] | void : never);
export type ExtraEvent<EM extends ChainedCallbackEventMap, K extends keyof EM = keyof EM> = K | {
    event: K;
    emitArgs?: Partial<EM[K]["emitArgs"]>;
};
export declare class ChainedAwaiatableEventEmitter<EM extends ChainedCallbackEventMap = DefaultChainedCallbackEventMap, SYNCEM extends ChainedCallbackEventMap = {
    [k in keyof EM as (EM[k]["isPromise"] extends false ? k : never)]: EM[k];
}> {
    #private;
    callSyncChainWithKey<K extends keyof EM & keyof SYNCEM, CK extends string & keyof EM[K]["emitArgs"] & EM[K]["returnEmitName"]>(eventName: K, // weird - but this is what enforces the keyof SYNCEM
    emitArgs: EM[K]["emitArgs"], chainKey: CK | undefined, options: StandardInvokeHookOptions<EM, K> | undefined): EM[K]["returns"];
    callAllSyncChainWithKey<K extends keyof EM & keyof SYNCEM, MK extends keyof EM & keyof SYNCEM, CK extends string & keyof EM[MK]["emitArgs"] & EM[MK]["returnEmitName"]>(emitArgs: EM[MK]["emitArgs"], chainKey: CK | undefined, options: StandardInvokeHookOptions<EM, K | MK> | undefined, masterEventName: MK, ...otherEventNames: K[]): void;
    callAllSync<K extends keyof EM & keyof SYNCEM, MK extends keyof EM & keyof SYNCEM>(emitArgs: EM[MK]["emitArgs"], options: StandardInvokeHookOptions<EM, K | MK> | undefined, masterEventName: MK, ...additionalEvents: ExtraEvent<SYNCEM | EM, K>[]): void;
    callAwaitableChainWithKey<K extends keyof EM, CK extends string & keyof EM[K]["emitArgs"] & EM[K]["returnEmitName"]>(eventName: K, emitArgs: EM[K]["emitArgs"], chainKey: CK, options: StandardInvokeHookOptions<EM, K> | undefined): Promise<EM[K]["returns"]>;
    callAllAwaitableInParallel<MK extends keyof EM, K extends keyof EM>(emitArgs: EM[MK]["emitArgs"], options: StandardInvokeHookOptions<EM, MK | K> | undefined, masterEventName: MK, ...additionalEvents: ExtraEvent<EM, K>[]): Promise<Awaited<EM[K]["isPromise"] extends true ? void | EM[K]["returns"] | Promise<void | EM[K]["returns"]> : void | EM[K]["returns"]>[]>;
    callAllAwaitableChainWithKey<MK extends keyof EM, K extends keyof EM & string, CK extends string & keyof EM[MK]["emitArgs"] & EM[MK]["returnEmitName"]>(emitArgs: EM[MK]["emitArgs"], chainKey: CK, options: StandardInvokeHookOptions<EM, MK | K> | undefined, masterEventName: MK, ...additionalEvents: ExtraEvent<EM, K>[]): Promise<EM[K]["returns"]>;
    callExplicitAwaitableListenersChainWithKey<MK extends keyof EM, CK extends keyof EM[MK]["emitArgs"] & string & EM[MK]["returnEmitName"]>(masterEventName: MK, emitArgs: EM[MK]["emitArgs"], chainKey: CK, listenersWithOptions: CallbackAndOptionsOfEm<EM, MK>[], signal: AbortSignal | undefined): Promise<EM[MK]["returns"]>;
    allListenersWithOptions(): {
        listener: ChainedListenerCallback<EM, keyof EM>;
        options: EM[keyof EM]["options"] | undefined;
        eventName: keyof EM;
    }[];
    relevantAwaitableListeners<K extends keyof EM>(eventName: K, options?: StandardInvokeHookOptions<EM, K>): ChainedListenerCallback<EM, K>[];
    relevantAwaitableListenersWithOptions<K extends keyof EM>(eventName: K, options?: StandardInvokeHookOptions<EM, K>): CallbackAndOptionsOfEm<EM, K>[];
    awaitableListenersWithOptions<K extends keyof EM>(eventName: K): CallbackAndOptionsOfEm<EM, K>[];
    awaitableListeners<K extends keyof EM>(eventName: K): ChainedListenerCallback<EM, K>[];
    addListener<K extends keyof EM>(eventName: K, listener: ChainedListenerCallback<EM, K>, options?: EM[K]["options"]): this;
    awaitableOn<K extends keyof EM>(eventName: K, listener: ChainedListenerCallback<EM, K>, options?: EM[K]["options"]): this;
    awaitableOff<K extends keyof EM>(eventName: K, listener: ChainedListenerCallback<EM, K>): this;
    listenerCount(eventName: keyof EM): number;
    eventNames(): (keyof EM)[];
}
export {};