declare class MockerRegistry {
    private readonly registry;
    clear(): void;
    keys(): IterableIterator<string>;
    add(mock: MockedModule): void;
    register(json: MockedModuleSerialized): MockedModule;
    register(type: 'redirect', raw: string, url: string, redirect: string): RedirectedModule;
    register(type: 'manual', raw: string, url: string, factory: () => any): ManualMockedModule;
    register(type: 'automock', raw: string, url: string): AutomockedModule;
    register(type: 'autospy', raw: string, url: string): AutospiedModule;
    delete(id: string): void;
    get(id: string): MockedModule | undefined;
    has(id: string): boolean;
}
type MockedModule = AutomockedModule | AutospiedModule | ManualMockedModule | RedirectedModule;
type MockedModuleType = 'automock' | 'autospy' | 'manual' | 'redirect';
type MockedModuleSerialized = AutomockedModuleSerialized | AutospiedModuleSerialized | ManualMockedModuleSerialized | RedirectedModuleSerialized;
declare class AutomockedModule {
    raw: string;
    url: string;
    readonly type = "automock";
    constructor(raw: string, url: string);
    static fromJSON(data: AutomockedModuleSerialized): AutospiedModule;
    toJSON(): AutomockedModuleSerialized;
}
interface AutomockedModuleSerialized {
    type: 'automock';
    url: string;
    raw: string;
}
declare class AutospiedModule {
    raw: string;
    url: string;
    readonly type = "autospy";
    constructor(raw: string, url: string);
    static fromJSON(data: AutospiedModuleSerialized): AutospiedModule;
    toJSON(): AutospiedModuleSerialized;
}
interface AutospiedModuleSerialized {
    type: 'autospy';
    url: string;
    raw: string;
}
declare class RedirectedModule {
    raw: string;
    url: string;
    redirect: string;
    readonly type = "redirect";
    constructor(raw: string, url: string, redirect: string);
    static fromJSON(data: RedirectedModuleSerialized): RedirectedModule;
    toJSON(): RedirectedModuleSerialized;
}
interface RedirectedModuleSerialized {
    type: 'redirect';
    url: string;
    raw: string;
    redirect: string;
}
declare class ManualMockedModule {
    raw: string;
    url: string;
    factory: () => any;
    cache: Record<string | symbol, any> | undefined;
    readonly type = "manual";
    constructor(raw: string, url: string, factory: () => any);
    resolve(): Promise<Record<string | symbol, any>>;
    static fromJSON(data: ManualMockedModuleSerialized, factory: () => any): ManualMockedModule;
    toJSON(): ManualMockedModuleSerialized;
}
interface ManualMockedModuleSerialized {
    type: 'manual';
    url: string;
    raw: string;
}

type Awaitable<T> = T | PromiseLike<T>;
type ModuleMockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M = M>() => Promise<T>) => Awaitable<Partial<M>>;
type ModuleMockFactory = () => any;
interface ModuleMockOptions {
    spy?: boolean;
}

export { AutomockedModule as A, type MockedModuleType as M, RedirectedModule as R, MockerRegistry as a, ManualMockedModule as b, AutospiedModule as c, type MockedModule as d, type MockedModuleSerialized as e, type AutomockedModuleSerialized as f, type AutospiedModuleSerialized as g, type RedirectedModuleSerialized as h, type ManualMockedModuleSerialized as i, type ModuleMockFactory as j, type ModuleMockFactoryWithHelper as k, type ModuleMockOptions as l };