import { Logger } from '@open-draft/logger';
import { EventMap, Emitter, Listener } from 'strict-event-emitter';

type AnyFunction = (...args: any[]) => any;
type LazyCallbackReturnType<FnType extends AnyFunction> = Parameters<FnType> | [];
interface LazyCallback<FnType extends AnyFunction> {
    (...args: Parameters<FnType>): void;
    invoked(): Promise<LazyCallbackReturnType<FnType>>;
}

type LazyResponseCallback = (response: Response) => void;
type InteractiveRequest = globalThis.Request & {
    respondWith: LazyCallback<LazyResponseCallback>;
};

declare const IS_PATCHED_MODULE: unique symbol;
type RequestCredentials = 'omit' | 'include' | 'same-origin';
type HttpRequestEventMap = {
    request: [
        args: {
            request: InteractiveRequest;
            requestId: string;
        }
    ];
    response: [
        args: {
            response: Response;
            isMockedResponse: boolean;
            request: Request;
            requestId: string;
        }
    ];
};

interface QueueItem<Args extends Array<unknown>> {
    args: Args;
    done: Promise<void>;
}
declare enum AsyncEventEmitterReadyState {
    ACTIVE = "ACTIVE",
    DEACTIVATED = "DEACTIVATED"
}
declare class AsyncEventEmitter<Events extends EventMap> extends Emitter<Events> {
    readyState: AsyncEventEmitterReadyState;
    private logger;
    protected queue: Map<keyof Events, Array<QueueItem<Events[any]>>>;
    constructor();
    on<EventName extends keyof Events>(eventName: EventName, listener: Listener<any>): this;
    emit<EventName extends keyof Events>(eventName: EventName, ...data: Events[EventName]): boolean;
    /**
     * Returns a promise that resolves when all the listeners for the given event
     * has been called. Awaits asynchronous listeners.
     * If the event has no listeners, resolves immediately.
     */
    untilIdle<EventName extends keyof Events>(eventName: EventName, filter?: (item: QueueItem<Events[EventName]>) => boolean): Promise<void>;
    private openListenerQueue;
    removeAllListeners<EventName extends keyof Events>(eventName?: EventName): this;
    activate(): void;
    /**
     * Deactivate this event emitter.
     * Deactivated emitter can no longer emit and listen to events
     * and needs to be activated again in order to do so.
     */
    deactivate(): void;
    private isInternalEventName;
}

type InterceptorEventMap = Record<string, any>;
type InterceptorSubscription = () => void;
declare function getGlobalSymbol<V>(symbol: Symbol): V | undefined;
declare function deleteGlobalSymbol(symbol: Symbol): void;
declare enum InterceptorReadyState {
    INACTIVE = "INACTIVE",
    APPLYING = "APPLYING",
    APPLIED = "APPLIED",
    DISPOSING = "DISPOSING",
    DISPOSED = "DISPOSED"
}
type ExtractEventNames<Events extends Record<string, any>> = Events extends Record<infer EventName, any> ? EventName : never;
declare class Interceptor<Events extends InterceptorEventMap> {
    private readonly symbol;
    protected emitter: AsyncEventEmitter<Events>;
    protected subscriptions: Array<InterceptorSubscription>;
    protected logger: Logger;
    readyState: InterceptorReadyState;
    constructor(symbol: symbol);
    /**
     * Determine if this interceptor can be applied
     * in the current environment.
     */
    protected checkEnvironment(): boolean;
    /**
     * Apply this interceptor to the current process.
     * Returns an already running interceptor instance if it's present.
     */
    apply(): void;
    /**
     * Setup the module augments and stubs necessary for this interceptor.
     * This method is not run if there's a running interceptor instance
     * to prevent instantiating an interceptor multiple times.
     */
    protected setup(): void;
    /**
     * Listen to the interceptor's public events.
     */
    on<EventName extends ExtractEventNames<Events>>(eventName: EventName, listener: Listener<Events[EventName]>): void;
    /**
     * Disposes of any side-effects this interceptor has introduced.
     */
    dispose(): void;
    private getInstance;
    private setInstance;
    private clearInstance;
}

export { AsyncEventEmitter as A, ExtractEventNames as E, HttpRequestEventMap as H, IS_PATCHED_MODULE as I, RequestCredentials as R, InterceptorEventMap as a, InterceptorSubscription as b, InterceptorReadyState as c, deleteGlobalSymbol as d, Interceptor as e, InteractiveRequest as f, getGlobalSymbol as g };