Initial checkin of Blueprint-MCP plugin

tools/blueprint-mcp/node_modules/@vitest/mocker/dist/mocker.d-TnKRhz7N.d.ts

@@ -0,0 +1,81 @@
+import { MaybeMockedDeep } from '@vitest/spy';
+import { b as ModuleMockOptions, c as ModuleMockFactoryWithHelper, a as MockedModule, M as MockerRegistry, d as MockedModuleType } from './types.d-B8CCKmHt.js';
+import { C as CreateMockInstanceProcedure } from './index.d-C-sLYZi-.js';
+
+interface CompilerHintsOptions {
+	/**
+	* This is the key used to access the globalThis object in the worker.
+	* Unlike `globalThisAccessor` in other APIs, this is not injected into the script.
+	* ```ts
+	* // globalThisKey: '__my_variable__' produces:
+	* globalThis['__my_variable__']
+	* // globalThisKey: '"__my_variable__"' produces:
+	* globalThis['"__my_variable__"'] // notice double quotes
+	* ```
+	* @default '__vitest_mocker__'
+	*/
+	globalThisKey?: string;
+}
+interface ModuleMockerCompilerHints {
+	hoisted: <T>(factory: () => T) => T;
+	mock: (path: string | Promise<unknown>, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void;
+	unmock: (path: string | Promise<unknown>) => void;
+	doMock: (path: string | Promise<unknown>, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void;
+	doUnmock: (path: string | Promise<unknown>) => void;
+	importActual: <T>(path: string) => Promise<T>;
+	importMock: <T>(path: string) => Promise<MaybeMockedDeep<T>>;
+}
+declare function createCompilerHints(options?: CompilerHintsOptions): ModuleMockerCompilerHints;
+
+interface ModuleMockerInterceptor {
+	register: (module: MockedModule) => Promise<void>;
+	delete: (url: string) => Promise<void>;
+	invalidate: () => Promise<void>;
+}
+
+declare class ModuleMocker {
+	private interceptor;
+	private rpc;
+	private createMockInstance;
+	private config;
+	protected registry: MockerRegistry;
+	private queue;
+	private mockedIds;
+	constructor(interceptor: ModuleMockerInterceptor, rpc: ModuleMockerRPC, createMockInstance: CreateMockInstanceProcedure, config: ModuleMockerConfig);
+	prepare(): Promise<void>;
+	resolveFactoryModule(id: string): Promise<Record<string | symbol, any>>;
+	getFactoryModule(id: string): any;
+	invalidate(): Promise<void>;
+	importActual<T>(id: string, importer: string): Promise<T>;
+	importMock<T>(rawId: string, importer: string): Promise<T>;
+	mockObject(object: Record<string | symbol, any>, moduleType?: "automock" | "autospy"): Record<string | symbol, any>;
+	queueMock(rawId: string, importer: string, factoryOrOptions?: ModuleMockOptions | (() => any)): void;
+	queueUnmock(id: string, importer: string): void;
+	wrapDynamicImport<T>(moduleFactory: () => Promise<T>): Promise<T>;
+	private resolveMockPath;
+}
+interface ResolveIdResult {
+	id: string;
+	url: string;
+	optimized: boolean;
+}
+interface ResolveMockResult {
+	mockType: MockedModuleType;
+	resolvedId: string;
+	resolvedUrl: string;
+	redirectUrl?: string | null;
+	needsInterop?: boolean;
+}
+interface ModuleMockerRPC {
+	invalidate: (ids: string[]) => Promise<void>;
+	resolveId: (id: string, importer: string) => Promise<ResolveIdResult | null>;
+	resolveMock: (id: string, importer: string, options: {
+		mock: "spy" | "factory" | "auto";
+	}) => Promise<ResolveMockResult>;
+}
+interface ModuleMockerConfig {
+	root: string;
+}
+
+export { ModuleMocker as b, createCompilerHints as c };
+export type { CompilerHintsOptions as C, ModuleMockerInterceptor as M, ResolveIdResult as R, ModuleMockerCompilerHints as a, ModuleMockerConfig as d, ModuleMockerRPC as e, ResolveMockResult as f };