@depup/vitest__mocker 4.1.0-depup.0

package/dist/node.js

@@ -0,0 +1,409 @@
+import { a as cleanUrl, c as createManualModuleSource } from './chunk-utils.js';
+import { a as automockModule, e as esmWalker } from './chunk-automock.js';
+import MagicString from 'magic-string';
+import { createFilter } from 'vite';
+import { h as hoistMocks } from './chunk-hoistMocks.js';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path/posix';
+import { M as MockerRegistry, a as ManualMockedModule } from './chunk-registry.js';
+import { fileURLToPath } from 'node:url';
+import { existsSync, readFileSync } from 'node:fs';
+import { findMockRedirect } from './redirect.js';
+import { i as isAbsolute, j as join$1, r as resolve } from './chunk-pathe.M-eThtNZ.js';
+import 'estree-walker';
+import 'node:module';
+import 'node:path';
+import './chunk-helpers.js';
+
+function automockPlugin(options = {}) {
+	return {
+		name: "vitest:automock",
+		enforce: "post",
+		transform(code, id) {
+			if (id.includes("mock=automock") || id.includes("mock=autospy")) {
+				const mockType = id.includes("mock=automock") ? "automock" : "autospy";
+				const ms = automockModule(code, mockType, this.parse, options);
+				return {
+					code: ms.toString(),
+					map: ms.generateMap({
+						hires: "boundary",
+						source: cleanUrl(id)
+					})
+				};
+			}
+		}
+	};
+}
+
+const regexDynamicImport = /import\s*\(/;
+function dynamicImportPlugin(options = {}) {
+	return {
+		name: "vitest:browser:esm-injector",
+		enforce: "post",
+		transform(source, id) {
+			// TODO: test is not called for static imports
+			if (!regexDynamicImport.test(source)) {
+				return;
+			}
+			if (options.filter && !options.filter(id)) {
+				return;
+			}
+			return injectDynamicImport(source, id, this.parse, options);
+		}
+	};
+}
+function injectDynamicImport(code, id, parse, options = {}) {
+	if (code.includes("wrapDynamicImport")) {
+		return;
+	}
+	const s = new MagicString(code);
+	let ast;
+	try {
+		ast = parse(code);
+	} catch (err) {
+		console.error(`Cannot parse ${id}:\n${err.message}`);
+		return;
+	}
+	// 3. convert references to import bindings & import.meta references
+	esmWalker(ast, {
+		onImportMeta() {
+			// s.update(node.start, node.end, viImportMetaKey)
+		},
+		onDynamicImport(node) {
+			const globalThisAccessor = options.globalThisAccessor || "\"__vitest_mocker__\"";
+			const replaceString = `globalThis[${globalThisAccessor}].wrapDynamicImport(() => import(`;
+			const importSubstring = code.substring(node.start, node.end);
+			const hasIgnore = importSubstring.includes("/* @vite-ignore */");
+			s.overwrite(node.start, node.source.start, replaceString + (hasIgnore ? "/* @vite-ignore */ " : ""));
+			s.overwrite(node.end - 1, node.end, "))");
+		}
+	});
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			hires: "boundary",
+			source: id
+		})
+	};
+}
+
+function hoistMocksPlugin(options = {}) {
+	const filter = options.filter || createFilter(options.include, options.exclude);
+	const { hoistableMockMethodNames = ["mock", "unmock"], dynamicImportMockMethodNames = [
+		"mock",
+		"unmock",
+		"doMock",
+		"doUnmock"
+	], hoistedMethodNames = ["hoisted"], utilsObjectNames = ["vi", "vitest"] } = options;
+	const methods = new Set([
+		...hoistableMockMethodNames,
+		...hoistedMethodNames,
+		...dynamicImportMockMethodNames
+	]);
+	const regexpHoistable = new RegExp(`\\b(?:${utilsObjectNames.join("|")})\\s*\.\\s*(?:${Array.from(methods).join("|")})\\s*\\(`);
+	return {
+		name: "vitest:mocks",
+		enforce: "post",
+		transform(code, id) {
+			if (!filter(id)) {
+				return;
+			}
+			const s = hoistMocks(code, id, this.parse, {
+				regexpHoistable,
+				hoistableMockMethodNames,
+				hoistedMethodNames,
+				utilsObjectNames,
+				dynamicImportMockMethodNames,
+				...options
+			});
+			if (s) {
+				return {
+					code: s.toString(),
+					map: s.generateMap({
+						hires: "boundary",
+						source: cleanUrl(id)
+					})
+				};
+			}
+		}
+	};
+}
+// to keeb backwards compat
+function hoistMockAndResolve(code, id, parse, options = {}) {
+	const s = hoistMocks(code, id, parse, options);
+	if (s) {
+		return {
+			code: s.toString(),
+			map: s.generateMap({
+				hires: "boundary",
+				source: cleanUrl(id)
+			})
+		};
+	}
+}
+
+function interceptorPlugin(options = {}) {
+	const registry = options.registry || new MockerRegistry();
+	return {
+		name: "vitest:mocks:interceptor",
+		enforce: "pre",
+		load: {
+			order: "pre",
+			async handler(id) {
+				const mock = registry.getById(id);
+				if (!mock) {
+					return;
+				}
+				if (mock.type === "manual") {
+					const exports$1 = Object.keys(await mock.resolve());
+					const accessor = options.globalThisAccessor || "\"__vitest_mocker__\"";
+					return createManualModuleSource(mock.url, exports$1, accessor);
+				}
+				if (mock.type === "redirect") {
+					return readFile(mock.redirect, "utf-8");
+				}
+			}
+		},
+		transform: {
+			order: "post",
+			handler(code, id) {
+				const mock = registry.getById(id);
+				if (!mock) {
+					return;
+				}
+				if (mock.type === "automock" || mock.type === "autospy") {
+					const m = automockModule(code, mock.type, this.parse, { globalThisAccessor: options.globalThisAccessor });
+					return {
+						code: m.toString(),
+						map: m.generateMap({
+							hires: "boundary",
+							source: cleanUrl(id)
+						})
+					};
+				}
+			}
+		},
+		configureServer(server) {
+			server.ws.on("vitest:interceptor:register", (event) => {
+				if (event.type === "manual") {
+					const module = ManualMockedModule.fromJSON(event, async () => {
+						const keys = await getFactoryExports(event.url);
+						return Object.fromEntries(keys.map((key) => [key, null]));
+					});
+					registry.add(module);
+				} else {
+					if (event.type === "redirect") {
+						const redirectUrl = new URL(event.redirect);
+						event.redirect = join(server.config.root, redirectUrl.pathname);
+					}
+					registry.register(event);
+				}
+				server.ws.send("vitest:interceptor:register:result");
+			});
+			server.ws.on("vitest:interceptor:delete", (id) => {
+				registry.delete(id);
+				server.ws.send("vitest:interceptor:delete:result");
+			});
+			server.ws.on("vitest:interceptor:invalidate", () => {
+				registry.clear();
+				server.ws.send("vitest:interceptor:invalidate:result");
+			});
+			function getFactoryExports(url) {
+				server.ws.send("vitest:interceptor:resolve", url);
+				let timeout;
+				return new Promise((resolve, reject) => {
+					timeout = setTimeout(() => {
+						reject(new Error(`Timeout while waiting for factory exports of ${url}`));
+					}, 1e4);
+					server.ws.on("vitest:interceptor:resolved", ({ url: resolvedUrl, keys }) => {
+						if (resolvedUrl === url) {
+							clearTimeout(timeout);
+							resolve(keys);
+						}
+					});
+				});
+			}
+		}
+	};
+}
+
+const VALID_ID_PREFIX = "/@id/";
+class ServerMockResolver {
+	constructor(server, options = {}) {
+		this.server = server;
+		this.options = options;
+	}
+	async resolveMock(rawId, importer, options) {
+		const { id, fsPath, external } = await this.resolveMockId(rawId, importer);
+		const resolvedUrl = this.normalizeResolveIdToUrl({ id }).url;
+		if (options.mock === "factory") {
+			const manifest = getViteDepsManifest(this.server.config);
+			const needsInterop = manifest?.[fsPath]?.needsInterop ?? false;
+			return {
+				mockType: "manual",
+				resolvedId: id,
+				resolvedUrl,
+				needsInterop
+			};
+		}
+		if (options.mock === "spy") {
+			return {
+				mockType: "autospy",
+				resolvedId: id,
+				resolvedUrl
+			};
+		}
+		const redirectUrl = findMockRedirect(this.server.config.root, fsPath, external);
+		return {
+			mockType: redirectUrl === null ? "automock" : "redirect",
+			redirectUrl,
+			resolvedId: id,
+			resolvedUrl
+		};
+	}
+	invalidate(ids) {
+		ids.forEach((id) => {
+			const moduleGraph = this.server.moduleGraph;
+			const module = moduleGraph.getModuleById(id);
+			if (module) {
+				module.transformResult = null;
+			}
+		});
+	}
+	async resolveId(id, importer) {
+		const resolved = await this.server.pluginContainer.resolveId(id, importer, { ssr: false });
+		if (!resolved) {
+			return null;
+		}
+		return this.normalizeResolveIdToUrl(resolved);
+	}
+	normalizeResolveIdToUrl(resolved) {
+		const isOptimized = resolved.id.startsWith(withTrailingSlash(this.server.config.cacheDir));
+		let url;
+		// normalise the URL to be acceptable by the browser
+		// https://github.com/vitejs/vite/blob/14027b0f2a9b01c14815c38aab22baf5b29594bb/packages/vite/src/node/plugins/importAnalysis.ts#L103
+		const root = this.server.config.root;
+		if (resolved.id.startsWith(withTrailingSlash(root))) {
+			url = resolved.id.slice(root.length);
+		} else if (resolved.id !== "/@react-refresh" && isAbsolute(resolved.id) && existsSync(cleanUrl(resolved.id))) {
+			url = join$1("/@fs/", resolved.id);
+		} else {
+			url = resolved.id;
+		}
+		if (url[0] !== "." && url[0] !== "/") {
+			url = resolved.id.startsWith(VALID_ID_PREFIX) ? resolved.id : VALID_ID_PREFIX + resolved.id.replace("\0", "__x00__");
+		}
+		return {
+			id: resolved.id,
+			url,
+			optimized: isOptimized
+		};
+	}
+	async resolveMockId(rawId, importer) {
+		if (!this.server.moduleGraph.getModuleById(importer) && !importer.startsWith(this.server.config.root)) {
+			importer = join$1(this.server.config.root, importer);
+		}
+		const resolved = await this.server.pluginContainer.resolveId(rawId, importer, { ssr: false });
+		return this.resolveModule(rawId, resolved);
+	}
+	resolveModule(rawId, resolved) {
+		const id = resolved?.id || rawId;
+		const external = !isAbsolute(id) || isModuleDirectory(this.options, id) ? rawId : null;
+		return {
+			id,
+			fsPath: cleanUrl(id),
+			external
+		};
+	}
+}
+function isModuleDirectory(config, path) {
+	const moduleDirectories = config.moduleDirectories || ["/node_modules/"];
+	return moduleDirectories.some((dir) => path.includes(dir));
+}
+const metadata = new WeakMap();
+function getViteDepsManifest(config) {
+	if (metadata.has(config)) {
+		return metadata.get(config);
+	}
+	const cacheDirPath = getDepsCacheDir(config);
+	const metadataPath = resolve(cacheDirPath, "_metadata.json");
+	if (!existsSync(metadataPath)) {
+		return null;
+	}
+	const { optimized } = JSON.parse(readFileSync(metadataPath, "utf-8"));
+	const newManifest = {};
+	for (const name in optimized) {
+		const dep = optimized[name];
+		const file = resolve(cacheDirPath, dep.file);
+		newManifest[file] = {
+			hash: dep.fileHash,
+			needsInterop: dep.needsInterop
+		};
+	}
+	metadata.set(config, newManifest);
+	return newManifest;
+}
+function getDepsCacheDir(config) {
+	return resolve(config.cacheDir, "deps");
+}
+function withTrailingSlash(path) {
+	if (path.at(-1) !== "/") {
+		return `${path}/`;
+	}
+	return path;
+}
+
+// this is an implementation for public usage
+// vitest doesn't use this plugin directly
+function mockerPlugin(options = {}) {
+	let server;
+	const registerPath = resolve(fileURLToPath(new URL("./register.js", import.meta.url)));
+	return [
+		{
+			name: "vitest:mocker:ws-rpc",
+			config(_, { command }) {
+				if (command !== "serve") {
+					return;
+				}
+				return {
+					server: { preTransformRequests: false },
+					optimizeDeps: { exclude: ["@vitest/mocker/register", "@vitest/mocker/browser"] }
+				};
+			},
+			configureServer(server_) {
+				server = server_;
+				const mockResolver = new ServerMockResolver(server);
+				server.ws.on("vitest:mocks:resolveId", async ({ id, importer }) => {
+					const resolved = await mockResolver.resolveId(id, importer);
+					server.ws.send("vitest:mocks:resolvedId:result", resolved);
+				});
+				server.ws.on("vitest:mocks:resolveMock", async ({ id, importer, options }) => {
+					const resolved = await mockResolver.resolveMock(id, importer, options);
+					server.ws.send("vitest:mocks:resolveMock:result", resolved);
+				});
+				server.ws.on("vitest:mocks:invalidate", async ({ ids }) => {
+					mockResolver.invalidate(ids);
+					server.ws.send("vitest:mocks:invalidate:result");
+				});
+			},
+			async load(id) {
+				if (id !== registerPath) {
+					return;
+				}
+				if (!server) {
+					// mocker doesn't work during build
+					return "export {}";
+				}
+				const content = await readFile(registerPath, "utf-8");
+				const result = content.replace(/__VITEST_GLOBAL_THIS_ACCESSOR__/g, options.globalThisAccessor ?? "\"__vitest_mocker__\"").replace("__VITEST_MOCKER_ROOT__", JSON.stringify(server.config.root));
+				return result;
+			}
+		},
+		hoistMocksPlugin(options.hoistMocks),
+		interceptorPlugin(options),
+		automockPlugin(options),
+		dynamicImportPlugin(options)
+	];
+}
+
+export { ServerMockResolver, automockModule, automockPlugin, createManualModuleSource, dynamicImportPlugin, findMockRedirect, hoistMockAndResolve as hoistMocks, hoistMocksPlugin, interceptorPlugin, mockerPlugin };

package/dist/redirect.d.ts

@@ -0,0 +1,3 @@
+declare function findMockRedirect(root: string, mockPath: string, external: string | null): string | null;
+
+export { findMockRedirect };

package/dist/redirect.js

@@ -0,0 +1,79 @@
+import fs from 'node:fs';
+import module$1 from 'node:module';
+import { d as dirname, j as join, b as basename, r as resolve, e as extname } from './chunk-pathe.M-eThtNZ.js';
+
+const { existsSync, readdirSync, statSync } = fs;
+function findMockRedirect(root, mockPath, external) {
+	const path = external || mockPath;
+	// it's a node_module alias
+	// all mocks should be inside <root>/__mocks__
+	if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
+		const mockDirname = dirname(path);
+		const mockFolder = join(root, "__mocks__", mockDirname);
+		if (!existsSync(mockFolder)) {
+			return null;
+		}
+		const baseOriginal = basename(path);
+		function findFile(mockFolder, baseOriginal) {
+			const files = readdirSync(mockFolder);
+			for (const file of files) {
+				const baseFile = basename(file, extname(file));
+				if (baseFile === baseOriginal) {
+					const path = resolve(mockFolder, file);
+					// if the same name, return the file
+					if (statSync(path).isFile()) {
+						return path;
+					} else {
+						// find folder/index.{js,ts}
+						const indexFile = findFile(path, "index");
+						if (indexFile) {
+							return indexFile;
+						}
+					}
+				}
+			}
+			return null;
+		}
+		return findFile(mockFolder, baseOriginal);
+	}
+	const dir = dirname(path);
+	const baseId = basename(path);
+	const fullPath = resolve(dir, "__mocks__", baseId);
+	return existsSync(fullPath) ? fullPath : null;
+}
+const builtins = new Set([
+	...module$1.builtinModules,
+	"assert/strict",
+	"diagnostics_channel",
+	"dns/promises",
+	"fs/promises",
+	"path/posix",
+	"path/win32",
+	"readline/promises",
+	"stream/consumers",
+	"stream/promises",
+	"stream/web",
+	"timers/promises",
+	"util/types",
+	"wasi"
+]);
+// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
+const prefixedBuiltins = new Set([
+	"node:sea",
+	"node:sqlite",
+	"node:test",
+	"node:test/reporters"
+]);
+const NODE_BUILTIN_NAMESPACE = "node:";
+function isNodeBuiltin(id) {
+	// Added in v18.6.0
+	if (module$1.isBuiltin) {
+		return module$1.isBuiltin(id);
+	}
+	if (prefixedBuiltins.has(id)) {
+		return true;
+	}
+	return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(NODE_BUILTIN_NAMESPACE.length) : id);
+}
+
+export { findMockRedirect };

package/dist/register.d.ts

@@ -0,0 +1,9 @@
+import { M as ModuleMockerInterceptor, a as ModuleMockerCompilerHints, b as ModuleMocker } from './mocker.d-QEntlm6J.js';
+import '@vitest/spy';
+import './types.d-BjI5eAwu.js';
+import './index.d-B41z0AuW.js';
+
+declare function registerModuleMocker(interceptor: (accessor: string) => ModuleMockerInterceptor): ModuleMockerCompilerHints;
+declare function registerNativeFactoryResolver(mocker: ModuleMocker): void;
+
+export { registerModuleMocker, registerNativeFactoryResolver };

package/dist/register.js

@@ -0,0 +1,42 @@
+import { createMockInstance } from '@vitest/spy';
+import { M as ModuleMocker, r as rpc, c as createCompilerHints, h as hot } from './chunk-mocker.js';
+import './chunk-helpers.js';
+import './index.js';
+import './chunk-registry.js';
+import './chunk-pathe.M-eThtNZ.js';
+
+function registerModuleMocker(interceptor) {
+	const mocker = new ModuleMocker(interceptor(__VITEST_GLOBAL_THIS_ACCESSOR__), {
+		resolveId(id, importer) {
+			return rpc("vitest:mocks:resolveId", {
+				id,
+				importer
+			});
+		},
+		resolveMock(id, importer, options) {
+			return rpc("vitest:mocks:resolveMock", {
+				id,
+				importer,
+				options
+			});
+		},
+		async invalidate(ids) {
+			return rpc("vitest:mocks:invalidate", { ids });
+		}
+	}, createMockInstance, { root: __VITEST_MOCKER_ROOT__ });
+	globalThis[__VITEST_GLOBAL_THIS_ACCESSOR__] = mocker;
+	registerNativeFactoryResolver(mocker);
+	return createCompilerHints({ globalThisKey: __VITEST_GLOBAL_THIS_ACCESSOR__ });
+}
+function registerNativeFactoryResolver(mocker) {
+	hot.on("vitest:interceptor:resolve", async (url) => {
+		const exports$1 = await mocker.resolveFactoryModule(url);
+		const keys = Object.keys(exports$1);
+		hot.send("vitest:interceptor:resolved", {
+			url,
+			keys
+		});
+	});
+}
+
+export { registerModuleMocker, registerNativeFactoryResolver };

package/dist/transforms.d.ts

@@ -0,0 +1,8 @@
+export { c as createManualModuleSource, h as hoistMocks } from './hoistMocks.d-w2ILr1dG.js';
+export { automockModule } from './automock.js';
+import 'magic-string';
+
+declare function initSyntaxLexers(): Promise<void>;
+declare function collectModuleExports(filename: string, code: string, format: "module" | "commonjs", exports?: string[]): string[];
+
+export { collectModuleExports, initSyntaxLexers };

package/dist/transforms.js

@@ -0,0 +1,10 @@
+export { c as createManualModuleSource } from './chunk-utils.js';
+export { a as automockModule, c as collectModuleExports, i as initSyntaxLexers } from './chunk-automock.js';
+export { h as hoistMocks } from './chunk-hoistMocks.js';
+import 'node:fs';
+import 'node:url';
+import 'magic-string';
+import 'estree-walker';
+import 'node:module';
+import 'node:path';
+import './chunk-helpers.js';

package/dist/types.d-BjI5eAwu.d.ts

@@ -0,0 +1,123 @@
+declare class MockerRegistry {
+	private readonly registryByUrl;
+	private readonly registryById;
+	clear(): void;
+	keys(): IterableIterator<string>;
+	add(mock: MockedModule): void;
+	register(json: MockedModuleSerialized): MockedModule;
+	register(type: "redirect", raw: string, id: string, url: string, redirect: string): RedirectedModule;
+	register(type: "manual", raw: string, id: string, url: string, factory: () => any): ManualMockedModule;
+	register(type: "automock", raw: string, id: string, url: string): AutomockedModule;
+	register(type: "autospy", id: string, raw: string, url: string): AutospiedModule;
+	delete(id: string): void;
+	deleteById(id: string): void;
+	get(id: string): MockedModule | undefined;
+	getById(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;
+	id: string;
+	url: string;
+	readonly type = "automock";
+	constructor(raw: string, id: string, url: string);
+	static fromJSON(data: AutomockedModuleSerialized): AutospiedModule;
+	toJSON(): AutomockedModuleSerialized;
+}
+interface AutomockedModuleSerialized {
+	type: "automock";
+	url: string;
+	raw: string;
+	id: string;
+}
+declare class AutospiedModule {
+	raw: string;
+	id: string;
+	url: string;
+	readonly type = "autospy";
+	constructor(raw: string, id: string, url: string);
+	static fromJSON(data: AutospiedModuleSerialized): AutospiedModule;
+	toJSON(): AutospiedModuleSerialized;
+}
+interface AutospiedModuleSerialized {
+	type: "autospy";
+	url: string;
+	raw: string;
+	id: string;
+}
+declare class RedirectedModule {
+	raw: string;
+	id: string;
+	url: string;
+	redirect: string;
+	readonly type = "redirect";
+	constructor(raw: string, id: string, url: string, redirect: string);
+	static fromJSON(data: RedirectedModuleSerialized): RedirectedModule;
+	toJSON(): RedirectedModuleSerialized;
+}
+interface RedirectedModuleSerialized {
+	type: "redirect";
+	url: string;
+	id: string;
+	raw: string;
+	redirect: string;
+}
+declare class ManualMockedModule<T = any> {
+	raw: string;
+	id: string;
+	url: string;
+	factory: () => T;
+	cache: T | undefined;
+	readonly type = "manual";
+	constructor(raw: string, id: string, url: string, factory: () => T);
+	resolve(): T;
+	static fromJSON(data: ManualMockedModuleSerialized, factory: () => any): ManualMockedModule;
+	toJSON(): ManualMockedModuleSerialized;
+}
+interface ManualMockedModuleSerialized {
+	type: "manual";
+	url: string;
+	id: 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;
+}
+interface ServerMockResolution {
+	mockType: "manual" | "redirect" | "automock" | "autospy";
+	resolvedId: string;
+	resolvedUrl: string;
+	needsInterop?: boolean;
+	redirectUrl?: string | null;
+}
+interface ServerIdResolution {
+	id: string;
+	url: string;
+	optimized: boolean;
+}
+interface ModuleMockContext {
+	/**
+	* When mocking with a factory, this refers to the module that imported the mock.
+	*/
+	callstack: null | string[];
+}
+interface TestModuleMocker {
+	queueMock(id: string, importer: string, factoryOrOptions?: ModuleMockFactory | ModuleMockOptions): void;
+	queueUnmock(id: string, importer: string): void;
+	importActual<T>(rawId: string, importer: string, callstack?: string[] | null): Promise<T>;
+	importMock(rawId: string, importer: string): Promise<any>;
+	mockObject(object: Record<string | symbol, any>, moduleType?: "automock" | "autospy"): Record<string | symbol, any>;
+	mockObject(object: Record<string | symbol, any>, mockExports: Record<string | symbol, any> | undefined, moduleType?: "automock" | "autospy"): Record<string | symbol, any>;
+	getMockContext(): ModuleMockContext;
+	reset(): void;
+}
+
+export { AutomockedModule as A, MockerRegistry as M, RedirectedModule as R, AutospiedModule as h, ManualMockedModule as j };
+export type { ServerMockResolution as S, TestModuleMocker as T, MockedModule as a, ModuleMockOptions as b, ModuleMockFactoryWithHelper as c, MockedModuleType as d, ModuleMockContext as e, ServerIdResolution as f, AutomockedModuleSerialized as g, AutospiedModuleSerialized as i, ManualMockedModuleSerialized as k, MockedModuleSerialized as l, ModuleMockFactory as m, RedirectedModuleSerialized as n };