@plyaz/types 1.5.1 → 1.5.3

package/dist/testing/common/mocks/types.d.ts

@@ -56,32 +56,32 @@ import type * as NextLink from 'next/link';
  */
 export interface MockFS {
     /** Async read file */
-    readFile: Vitest.MockInstance;
+    readFile: Vitest.Mock;
     /** Async write file */
-    writeFile: Vitest.MockInstance;
+    writeFile: Vitest.Mock;
     /** Sync read file */
-    readFileSync: Vitest.MockInstance;
+    readFileSync: Vitest.Mock;
     /** Sync write file */
-    writeFileSync: Vitest.MockInstance;
+    writeFileSync: Vitest.Mock;
     /** Check if path exists */
-    existsSync: Vitest.MockInstance;
+    existsSync: Vitest.Mock;
     /** Create directory */
-    mkdirSync: Vitest.MockInstance;
+    mkdirSync: Vitest.Mock;
     /** Read directory contents */
-    readdirSync: Vitest.MockInstance;
+    readdirSync: Vitest.Mock;
     /** Get file stats */
-    statSync: Vitest.MockInstance;
+    statSync: Vitest.Mock;
     /** Delete file */
-    unlinkSync: Vitest.MockInstance;
+    unlinkSync: Vitest.Mock;
     /** Remove file or directory */
-    rmSync: Vitest.MockInstance;
+    rmSync: Vitest.Mock;
 }
 /**
  * Mock process interface matching Node.js process global
  *
  * @example
  * ```typescript
- * const mockProcess: Vitest.MockInstanceProcess = createMockProcess();
+ * const mockProcess: Vitest.MockProcess = createMockProcess();
  *
  * // Mock environment
  * mockProcess.env.NODE_ENV = 'test';
@@ -96,25 +96,25 @@ export interface MockProcess {
     /** Environment variables */
     env: Record<string, string | undefined>;
     /** Exit the process */
-    exit: Vitest.MockInstance;
+    exit: Vitest.Mock;
     /** Get current working directory */
-    cwd: Vitest.MockInstance;
+    cwd: Vitest.Mock;
     /** Change current directory */
-    chdir: Vitest.MockInstance;
+    chdir: Vitest.Mock;
     /** Standard output stream */
     stdout: {
         /** Write to stdout */
-        write: Vitest.MockInstance;
+        write: Vitest.Mock;
     };
     /** Standard error stream */
     stderr: {
         /** Write to stderr */
-        write: Vitest.MockInstance;
+        write: Vitest.Mock;
     };
     /** Add event listener */
-    on: Vitest.MockInstance;
+    on: Vitest.Mock;
     /** Remove event listener */
-    removeListener: Vitest.MockInstance;
+    removeListener: Vitest.Mock;
 }
 /**
  * Mock crypto interface matching Node.js crypto module
@@ -135,13 +135,13 @@ export interface MockProcess {
  */
 export interface MockCrypto {
     /** Generate random bytes */
-    randomBytes: Vitest.MockInstance;
+    randomBytes: Vitest.Mock;
     /** Generate random UUID */
-    randomUUID: Vitest.MockInstance;
+    randomUUID: Vitest.Mock;
     /** Create hash object */
-    createHash: Vitest.MockInstance;
+    createHash: Vitest.Mock;
     /** Create HMAC object */
-    createHmac: Vitest.MockInstance;
+    createHmac: Vitest.Mock;
 }
 /**
  * Mock path interface matching Node.js path module
@@ -158,21 +158,21 @@ export interface MockCrypto {
  */
 export interface MockPath {
     /** Join path segments */
-    join: Vitest.MockInstance;
+    join: Vitest.Mock;
     /** Resolve absolute path */
-    resolve: Vitest.MockInstance;
+    resolve: Vitest.Mock;
     /** Get directory name */
-    dirname: Vitest.MockInstance;
+    dirname: Vitest.Mock;
     /** Get base name */
-    basename: Vitest.MockInstance;
+    basename: Vitest.Mock;
     /** Get file extension */
-    extname: Vitest.MockInstance;
+    extname: Vitest.Mock;
     /** Get relative path */
-    relative: Vitest.MockInstance;
+    relative: Vitest.Mock;
     /** Check if path is absolute */
-    isAbsolute: Vitest.MockInstance;
+    isAbsolute: Vitest.Mock;
     /** Normalize path */
-    normalize: Vitest.MockInstance;
+    normalize: Vitest.Mock;
     /** Path separator for platform */
     sep: string;
 }
@@ -192,13 +192,13 @@ export interface MockPath {
  */
 export interface MockChildProcess {
     /** Spawn a new process */
-    spawn: Vitest.MockInstance;
+    spawn: Vitest.Mock;
     /** Execute command asynchronously */
-    exec: Vitest.MockInstance;
+    exec: Vitest.Mock;
     /** Execute command synchronously */
-    execSync: Vitest.MockInstance;
+    execSync: Vitest.Mock;
     /** Fork a child process */
-    fork: Vitest.MockInstance;
+    fork: Vitest.Mock;
 }
 /**
  * Mock timers interface for testing time-dependent code
@@ -220,17 +220,17 @@ export interface MockChildProcess {
  */
 export interface MockTimers {
     /** Schedule a timeout */
-    setTimeout: Vitest.MockInstance;
+    setTimeout: Vitest.Mock;
     /** Clear a timeout */
-    clearTimeout: Vitest.MockInstance;
+    clearTimeout: Vitest.Mock;
     /** Schedule an interval */
-    setInterval: Vitest.MockInstance;
+    setInterval: Vitest.Mock;
     /** Clear an interval */
-    clearInterval: Vitest.MockInstance;
+    clearInterval: Vitest.Mock;
     /** Schedule immediate execution */
-    setImmediate: Vitest.MockInstance;
+    setImmediate: Vitest.Mock;
     /** Clear immediate execution */
-    clearImmediate: Vitest.MockInstance;
+    clearImmediate: Vitest.Mock;
     /** Enable fake timers */
     useFakeTimers: () => void;
     /** Restore real timers */
@@ -265,39 +265,39 @@ export interface MockTimers {
  */
 export interface MockEventEmitter {
     /** Add event listener */
-    on: Vitest.MockInstance;
+    on: Vitest.Mock;
     /** Add one-time event listener */
-    once: Vitest.MockInstance;
+    once: Vitest.Mock;
     /** Remove event listener */
-    off: Vitest.MockInstance;
+    off: Vitest.Mock;
     /** Emit event to listeners */
-    emit: Vitest.MockInstance;
+    emit: Vitest.Mock;
     /** Emit event asynchronously */
-    emitAsync: Vitest.MockInstance;
+    emitAsync: Vitest.Mock;
     /** Remove specific listener */
-    removeListener: Vitest.MockInstance;
+    removeListener: Vitest.Mock;
     /** Remove all listeners for event */
-    removeAllListeners: Vitest.MockInstance;
+    removeAllListeners: Vitest.Mock;
     /** Alias for on() */
-    addListener: Vitest.MockInstance;
+    addListener: Vitest.Mock;
     /** Get listeners for event */
-    listeners: Vitest.MockInstance;
+    listeners: Vitest.Mock;
     /** Count listeners for event */
-    listenerCount: Vitest.MockInstance;
+    listenerCount: Vitest.Mock;
     /** Get all event names */
-    eventNames: Vitest.MockInstance;
+    eventNames: Vitest.Mock;
     /** Set max listeners limit */
-    setMaxListeners: Vitest.MockInstance;
+    setMaxListeners: Vitest.Mock;
     /** Get max listeners limit */
-    getMaxListeners: Vitest.MockInstance;
+    getMaxListeners: Vitest.Mock;
     /** Wait for specific event */
-    waitForEvent: Vitest.MockInstance;
+    waitForEvent: Vitest.Mock;
     /** Get raw listeners array */
-    rawListeners: Vitest.MockInstance;
+    rawListeners: Vitest.Mock;
     /** Prepend listener to start of list */
-    prependListener: Vitest.MockInstance;
+    prependListener: Vitest.Mock;
     /** Prepend one-time listener */
-    prependOnceListener: Vitest.MockInstance;
+    prependOnceListener: Vitest.Mock;
 }
 /**
  * Mock logger interface matching NestJS Logger methods
@@ -318,21 +318,21 @@ export interface MockEventEmitter {
  */
 export interface MockLogger {
     /** Log info message */
-    log: Vitest.MockInstance;
+    log: Vitest.Mock;
     /** Log error message */
-    error: Vitest.MockInstance;
+    error: Vitest.Mock;
     /** Log warning message */
-    warn: Vitest.MockInstance;
+    warn: Vitest.Mock;
     /** Log info message */
-    info: Vitest.MockInstance;
+    info: Vitest.Mock;
     /** Log debug message */
-    debug: Vitest.MockInstance;
+    debug: Vitest.Mock;
     /** Log verbose message */
-    verbose: Vitest.MockInstance;
+    verbose: Vitest.Mock;
     /** Set log level */
-    setLevel: Vitest.MockInstance;
+    setLevel: Vitest.Mock;
     /** Get log level */
-    getLevel: Vitest.MockInstance;
+    getLevel: Vitest.Mock;
 }
 /**
  * NestJS common decorators and exceptions mock interface
@@ -355,27 +355,27 @@ export interface MockLogger {
  */
 export interface NestJsCommonMocks {
     /** Injectable decorator mock */
-    Injectable: Vitest.MockInstance;
+    Injectable: Vitest.Mock;
     /** Inject decorator mock */
-    Inject: Vitest.MockInstance;
+    Inject: Vitest.Mock;
     /** Optional decorator mock */
-    Optional: Vitest.MockInstance;
+    Optional: Vitest.Mock;
     /** Logger class mock */
-    Logger: Vitest.MockInstance;
+    Logger: Vitest.Mock;
     /** HttpException class mock */
-    HttpException: Vitest.MockInstance;
+    HttpException: Vitest.Mock;
     /** HTTP status codes */
     HttpStatus: Record<string, number>;
     /** BadRequestException class mock */
-    BadRequestException: Vitest.MockInstance;
+    BadRequestException: Vitest.Mock;
     /** NotFoundException class mock */
-    NotFoundException: Vitest.MockInstance;
+    NotFoundException: Vitest.Mock;
     /** UnauthorizedException class mock */
-    UnauthorizedException: Vitest.MockInstance;
+    UnauthorizedException: Vitest.Mock;
     /** ForbiddenException class mock */
-    ForbiddenException: Vitest.MockInstance;
+    ForbiddenException: Vitest.Mock;
     /** InternalServerErrorException class mock */
-    InternalServerErrorException: Vitest.MockInstance;
+    InternalServerErrorException: Vitest.Mock;
 }
 /**
  * Mock CRUD service interface for testing data operations
@@ -392,15 +392,15 @@ export interface NestJsCommonMocks {
  */
 export interface CrudServiceMock {
     /** Find all entities */
-    findAll: Vitest.MockInstance;
+    findAll: Vitest.Mock;
     /** Find one entity */
-    findOne: Vitest.MockInstance;
+    findOne: Vitest.Mock;
     /** Create new entity */
-    create: Vitest.MockInstance;
+    create: Vitest.Mock;
     /** Update existing entity */
-    update: Vitest.MockInstance;
+    update: Vitest.Mock;
     /** Remove entity */
-    remove: Vitest.MockInstance;
+    remove: Vitest.Mock;
 }
 /**
  * Mock NestJS testing module interface
@@ -490,7 +490,7 @@ export interface MockContextValue<T = unknown> {
     /** Current context value */
     value: T;
     /** Function to update context value */
-    setValue: Vitest.MockInstance;
+    setValue: Vitest.Mock;
 }
 /**
  * Mock React context provider interface
@@ -546,17 +546,17 @@ export interface MockProvider<T = unknown> {
  */
 export interface MockRouter {
     /** Navigate to new route */
-    push: Vitest.MockInstance;
+    push: Vitest.Mock;
     /** Replace current route */
-    replace: Vitest.MockInstance;
+    replace: Vitest.Mock;
     /** Go back in history */
-    back: Vitest.MockInstance;
+    back: Vitest.Mock;
     /** Go forward in history */
-    forward: Vitest.MockInstance;
+    forward: Vitest.Mock;
     /** Refresh current page */
-    refresh: Vitest.MockInstance;
+    refresh: Vitest.Mock;
     /** Prefetch route */
-    prefetch: Vitest.MockInstance;
+    prefetch: Vitest.Mock;
     /** Current pathname */
     pathname: string;
     /** Query parameters */
@@ -577,7 +577,7 @@ export interface MockRouter {
         state: unknown;
     };
     /** Navigation history */
-    history: Array<MockHistoryEntry>;
+    history: Array<HistoryEntry>;
 }
 /**
  * Mock React hooks interface for testing hook behavior
@@ -597,21 +597,21 @@ export interface MockRouter {
  */
 export interface MockHooks {
     /** Mock useState hook */
-    useState: Vitest.MockInstance;
+    useState: Vitest.Mock;
     /** Mock useEffect hook */
-    useEffect: Vitest.MockInstance;
+    useEffect: Vitest.Mock;
     /** Mock useContext hook */
-    useContext: Vitest.MockInstance;
+    useContext: Vitest.Mock;
     /** Mock useReducer hook */
-    useReducer: Vitest.MockInstance;
+    useReducer: Vitest.Mock;
     /** Mock useCallback hook */
-    useCallback: Vitest.MockInstance;
+    useCallback: Vitest.Mock;
     /** Mock useMemo hook */
-    useMemo: Vitest.MockInstance;
+    useMemo: Vitest.Mock;
     /** Mock useRef hook */
-    useRef: Vitest.MockInstance;
+    useRef: Vitest.Mock;
     /** Mock useLayoutEffect hook */
-    useLayoutEffect: Vitest.MockInstance;
+    useLayoutEffect: Vitest.Mock;
 }
 /**
  * Mock fetch interface for testing HTTP requests
@@ -632,7 +632,7 @@ export interface MockHooks {
  */
 export interface MockFetch {
     /** Main fetch mock function */
-    mock: Vitest.MockInstance;
+    mock: Vitest.Mock;
     /** Mock successful response */
     mockResponse: (response: unknown, options?: ResponseInit) => void;
     /** Mock error response */
@@ -660,17 +660,17 @@ export interface MockFetch {
  */
 export interface MockLocalStorage {
     /** Get item from storage */
-    getItem: Vitest.MockInstance;
+    getItem: Vitest.Mock;
     /** Set item in storage */
-    setItem: Vitest.MockInstance;
+    setItem: Vitest.Mock;
     /** Remove item from storage */
-    removeItem: Vitest.MockInstance;
+    removeItem: Vitest.Mock;
     /** Clear all storage */
-    clear: Vitest.MockInstance;
+    clear: Vitest.Mock;
     /** Number of items in storage */
     length: number;
     /** Get key at index */
-    key: Vitest.MockInstance;
+    key: Vitest.Mock;
 }
 /**
  * Mock IntersectionObserver instance interface
@@ -696,11 +696,11 @@ export interface MockIntersectionObserverInstance {
     /** Set of observed elements */
     elements: Set<Element>;
     /** Start observing element */
-    observe: Vitest.MockInstance;
+    observe: Vitest.Mock;
     /** Stop observing element */
-    unobserve: Vitest.MockInstance;
+    unobserve: Vitest.Mock;
     /** Disconnect all observations */
-    disconnect: Vitest.MockInstance;
+    disconnect: Vitest.Mock;
     /** Manually trigger intersection entries */
     trigger: (entries: IntersectionObserverEntry[]) => void;
 }
@@ -722,7 +722,7 @@ export interface MockIntersectionObserverInstance {
  */
 export interface MockIntersectionObserver {
     /** IntersectionObserver constructor mock */
-    MockIntersectionObserver: Vitest.MockInstance;
+    MockIntersectionObserver: Vitest.Mock;
     /** Array of observer instances */
     instances: MockIntersectionObserverInstance[];
     /** Trigger intersection for specific entries */
@@ -732,11 +732,11 @@ export interface MockIntersectionObserver {
     /** Reset all observers */
     reset: () => void;
     /** Observe element mock */
-    observe: Vitest.MockInstance;
+    observe: Vitest.Mock;
     /** Unobserve element mock */
-    unobserve: Vitest.MockInstance;
+    unobserve: Vitest.Mock;
     /** Disconnect observer mock */
-    disconnect: Vitest.MockInstance;
+    disconnect: Vitest.Mock;
     /** Current observer callback */
     callback: ((entries: IntersectionObserverEntry[]) => void) | null;
 }
@@ -759,27 +759,27 @@ export interface MockIntersectionObserver {
  */
 export interface MockNextRouter extends Omit<NextRouter.NextRouter, 'push' | 'replace' | 'reload' | 'back' | 'forward' | 'prefetch' | 'beforePopState' | 'events'> {
     /** Navigate to new route */
-    push: Vitest.MockInstance;
+    push: Vitest.Mock;
     /** Replace current route */
-    replace: Vitest.MockInstance;
+    replace: Vitest.Mock;
     /** Reload current page */
-    reload: Vitest.MockInstance;
+    reload: Vitest.Mock;
     /** Go back in history */
-    back: Vitest.MockInstance;
+    back: Vitest.Mock;
     /** Go forward in history */
-    forward: Vitest.MockInstance;
+    forward: Vitest.Mock;
     /** Prefetch route */
-    prefetch: Vitest.MockInstance;
+    prefetch: Vitest.Mock;
     /** Set before pop state handler */
-    beforePopState: Vitest.MockInstance;
+    beforePopState: Vitest.Mock;
     /** Router events */
     events: {
         /** Add event listener */
-        on: Vitest.MockInstance;
+        on: Vitest.Mock;
         /** Remove event listener */
-        off: Vitest.MockInstance;
+        off: Vitest.Mock;
         /** Emit router event */
-        emit: Vitest.MockInstance;
+        emit: Vitest.Mock;
     };
     pathname: string;
     route: string;
@@ -855,23 +855,23 @@ export type MockNextApiRequest = Partial<Next.NextApiRequest> & {
  */
 export interface MockNextApiResponse {
     /** Set response status */
-    status: Vitest.MockInstance;
+    status: Vitest.Mock;
     /** Send JSON response */
-    json: Vitest.MockInstance;
+    json: Vitest.Mock;
     /** Send response */
-    send: Vitest.MockInstance;
+    send: Vitest.Mock;
     /** Redirect response */
-    redirect: Vitest.MockInstance;
+    redirect: Vitest.Mock;
     /** Set response header */
-    setHeader: Vitest.MockInstance;
+    setHeader: Vitest.Mock;
     /** Get response header */
-    getHeader: Vitest.MockInstance;
+    getHeader: Vitest.Mock;
     /** Remove response header */
-    removeHeader: Vitest.MockInstance;
+    removeHeader: Vitest.Mock;
     /** Write to response */
-    write: Vitest.MockInstance;
+    write: Vitest.Mock;
     /** End response */
-    end: Vitest.MockInstance;
+    end: Vitest.Mock;
     /** Current status code */
     statusCode: number;
     /** Current status message */
@@ -928,21 +928,21 @@ export type MockGetStaticPropsContext = Next.GetStaticPropsContext;
  */
 export interface MockSearchParams {
     /** Get parameter value */
-    get: Vitest.MockInstance;
+    get: Vitest.Mock;
     /** Get all values for parameter */
-    getAll: Vitest.MockInstance;
+    getAll: Vitest.Mock;
     /** Check if parameter exists */
-    has: Vitest.MockInstance;
+    has: Vitest.Mock;
     /** Get all parameter keys */
-    keys: Vitest.MockInstance;
+    keys: Vitest.Mock;
     /** Get all parameter values */
-    values: Vitest.MockInstance;
+    values: Vitest.Mock;
     /** Get all key-value entries */
-    entries: Vitest.MockInstance;
+    entries: Vitest.Mock;
     /** Iterate over parameters */
-    forEach: Vitest.MockInstance;
+    forEach: Vitest.Mock;
     /** Convert to string */
-    toString: Vitest.MockInstance;
+    toString: Vitest.Mock;
 }
 /**
  * Mock Next.js environment variables interface
@@ -1040,19 +1040,19 @@ export interface MockHttpRequest {
         remotePort: number;
     };
     /** Add event listener */
-    on?: Vitest.MockInstance;
+    on?: Vitest.Mock;
     /** Add one-time event listener */
-    once?: Vitest.MockInstance;
+    once?: Vitest.Mock;
     /** Emit event */
-    emit?: Vitest.MockInstance;
+    emit?: Vitest.Mock;
     /** Pipe to stream */
-    pipe?: Vitest.MockInstance;
+    pipe?: Vitest.Mock;
     /** Unpipe from stream */
-    unpipe?: Vitest.MockInstance;
+    unpipe?: Vitest.Mock;
     /** Pause stream */
-    pause?: Vitest.MockInstance;
+    pause?: Vitest.Mock;
     /** Resume stream */
-    resume?: Vitest.MockInstance;
+    resume?: Vitest.Mock;
 }
 /**
  * Mock HTTP response interface for testing HTTP handlers
@@ -1076,31 +1076,31 @@ export interface MockHttpResponse {
     /** Current status message */
     statusMessage: string;
     /** Set status code */
-    status: Vitest.MockInstance;
+    status: Vitest.Mock;
     /** Send JSON response */
-    json: Vitest.MockInstance;
+    json: Vitest.Mock;
     /** Send response */
-    send: Vitest.MockInstance;
+    send: Vitest.Mock;
     /** Set response header */
-    setHeader: Vitest.MockInstance;
+    setHeader: Vitest.Mock;
     /** Get response header */
-    getHeader: Vitest.MockInstance;
+    getHeader: Vitest.Mock;
     /** Remove response header */
-    removeHeader: Vitest.MockInstance;
+    removeHeader: Vitest.Mock;
     /** Write to response */
-    write: Vitest.MockInstance;
+    write: Vitest.Mock;
     /** End response */
-    end: Vitest.MockInstance;
+    end: Vitest.Mock;
     /** Write response head */
-    writeHead?: Vitest.MockInstance;
+    writeHead?: Vitest.Mock;
     /** Redirect response */
-    redirect?: Vitest.MockInstance;
+    redirect?: Vitest.Mock;
     /** Add event listener */
-    on?: Vitest.MockInstance;
+    on?: Vitest.Mock;
     /** Add one-time event listener */
-    once?: Vitest.MockInstance;
+    once?: Vitest.Mock;
     /** Emit event */
-    emit?: Vitest.MockInstance;
+    emit?: Vitest.Mock;
     /** Whether response is finished */
     finished?: boolean;
     /** Whether headers are sent */
@@ -1121,7 +1121,7 @@ export interface MockHttpResponse {
  * };
  * ```
  */
-export interface MockHistoryEntry {
+export interface HistoryEntry {
     /** URL pathname */
     pathname: string;
     /** URL search string */
@@ -1171,7 +1171,7 @@ export interface MiddlewareContext {
     /** Mock HTTP response */
     res: MockHttpResponse;
     /** Next function mock */
-    next: Vitest.MockInstance;
+    next: Vitest.Mock;
 }
 /**
  * Options for stream piping operations
@@ -1226,11 +1226,11 @@ export interface NextLinkChildProps {
  */
 export interface ErrorHandlerMock {
     /** Error event handler */
-    onError: Vitest.MockInstance;
+    onError: Vitest.Mock;
     /** Catch block handler */
-    onCatch: Vitest.MockInstance;
+    onCatch: Vitest.Mock;
     /** Finally block handler */
-    onFinally: Vitest.MockInstance;
+    onFinally: Vitest.Mock;
     /** Reset all handlers */
     reset: () => void;
 }
@@ -1322,21 +1322,21 @@ export interface TimerCallbackEntry {
  */
 export interface MockHttpServer {
     /** Start listening on port */
-    listen: Vitest.MockInstance;
+    listen: Vitest.Mock;
     /** Close server */
-    close: Vitest.MockInstance;
+    close: Vitest.Mock;
     /** Get server address */
-    address: Vitest.MockInstance;
+    address: Vitest.Mock;
     /** Active connections */
     connections: Set<unknown>;
     /** Get connection count */
-    getConnections: Vitest.MockInstance;
+    getConnections: Vitest.Mock;
     /** Add event listener */
-    on: Vitest.MockInstance;
+    on: Vitest.Mock;
     /** Add one-time event listener */
-    once: Vitest.MockInstance;
+    once: Vitest.Mock;
     /** Emit server event */
-    emit: Vitest.MockInstance;
+    emit: Vitest.Mock;
 }
 /**
  * Mock readable stream interface extending EventEmitter
@@ -1498,7 +1498,7 @@ export interface NestJsModuleMock {
  */
 export type CreateStatefulCounterMockReturn = StatefulMock<{
     value: number;
-}, Record<string, Vitest.MockInstance>>;
+}, Record<string, Vitest.Mock>>;
 /**
  * Base interface for stateful mocks with state management
  *
@@ -1571,7 +1571,7 @@ export interface StatefulMockOptions<TState> {
 /**
  * Type definition for createMockUseRouter function return
  */
-export type CreateMockUseRouterReturn = Vitest.MockInstance;
+export type CreateMockUseRouterReturn = Vitest.Mock;
 /**
  * Type definition for createMockWebSocket function return
  */
@@ -1582,24 +1582,24 @@ export interface CreateMockWebSocketReturn {
     readyState: number;
     bufferedAmount: number;
     binaryType: 'blob' | 'arraybuffer';
-    send: Vitest.MockInstance;
-    close: Vitest.MockInstance;
-    ping: Vitest.MockInstance;
-    pong: Vitest.MockInstance;
-    terminate: Vitest.MockInstance;
+    send: Vitest.Mock;
+    close: Vitest.Mock;
+    ping: Vitest.Mock;
+    pong: Vitest.Mock;
+    terminate: Vitest.Mock;
     messages: unknown[];
     simulateMessage: (data: unknown) => void;
     simulateError: (error: Error) => void;
     simulateClose: (code?: number, reason?: string) => void;
     simulateOpen: () => void;
-    on: Vitest.MockInstance;
-    off: Vitest.MockInstance;
-    emit: Vitest.MockInstance;
-    addListener: Vitest.MockInstance;
-    removeListener: Vitest.MockInstance;
-    removeAllListeners: Vitest.MockInstance;
-    listeners: Vitest.MockInstance;
-    listenerCount: Vitest.MockInstance;
+    on: Vitest.Mock;
+    off: Vitest.Mock;
+    emit: Vitest.Mock;
+    addListener: Vitest.Mock;
+    removeListener: Vitest.Mock;
+    removeAllListeners: Vitest.Mock;
+    listeners: Vitest.Mock;
+    listenerCount: Vitest.Mock;
 }
 /**
  * Type definition for middlewareUtils.createMockNextRequest function
@@ -1623,9 +1623,9 @@ export type CreateMockNextRequestFunction = (url: string, options?: {
         href: string;
     };
     cookies: {
-        get: Vitest.MockInstance;
-        set: Vitest.MockInstance;
-        delete: Vitest.MockInstance;
+        get: Vitest.Mock;
+        set: Vitest.Mock;
+        delete: Vitest.Mock;
     };
     geo: {
         city: string;
@@ -1643,22 +1643,22 @@ export interface CreateMockWebSocketServerReturn {
     port: number;
     host: string;
     maxClients: number;
-    handleUpgrade: Vitest.MockInstance;
-    shouldHandle: Vitest.MockInstance;
-    close: Vitest.MockInstance;
+    handleUpgrade: Vitest.Mock;
+    shouldHandle: Vitest.Mock;
+    close: Vitest.Mock;
     addClient: (client: CreateMockWebSocketReturn) => void;
     removeClient: (client: CreateMockWebSocketReturn) => void;
     simulateConnection: (clientId?: string) => CreateMockWebSocketReturn;
     simulateBroadcast: (data: unknown, excludeClient?: string) => void;
     simulateClientDisconnect: (clientId: string) => void;
-    on: Vitest.MockInstance;
-    off: Vitest.MockInstance;
-    emit: Vitest.MockInstance;
-    addListener: Vitest.MockInstance;
-    removeListener: Vitest.MockInstance;
-    removeAllListeners: Vitest.MockInstance;
-    listeners: Vitest.MockInstance;
-    listenerCount: Vitest.MockInstance;
+    on: Vitest.Mock;
+    off: Vitest.Mock;
+    emit: Vitest.Mock;
+    addListener: Vitest.Mock;
+    removeListener: Vitest.Mock;
+    removeAllListeners: Vitest.Mock;
+    listeners: Vitest.Mock;
+    listenerCount: Vitest.Mock;
 }
 /**
  * Console mock with advanced capture and filtering
@@ -1666,11 +1666,11 @@ export interface CreateMockWebSocketServerReturn {
  * @public
  */
 export interface AdvancedConsoleMock {
-    log: Vitest.MockInstance;
-    warn: Vitest.MockInstance;
-    error: Vitest.MockInstance;
-    info: Vitest.MockInstance;
-    debug: Vitest.MockInstance;
+    log: Vitest.Mock;
+    warn: Vitest.Mock;
+    error: Vitest.Mock;
+    info: Vitest.Mock;
+    debug: Vitest.Mock;
     logs: string[];
     warnings: string[];
     errors: string[];
@@ -1694,256 +1694,487 @@ export interface AdvancedConsoleMock {
     getLastError: () => string | undefined;
 }
 /**
- * Mock FormData implementation
- * @interface MockFormData
+ * Mock FormData implementation for testing form data handling.
+ * Simulates browser FormData API for testing file uploads and form submissions.
+ *
+ * @example
+ * ```typescript
+ * const mockFormData: MockFormData = {
+ *   append: vi.fn(),
+ *   delete: vi.fn(),
+ *   get: vi.fn().mockReturnValue('value'),
+ *   getAll: vi.fn().mockReturnValue(['value1', 'value2']),
+ *   has: vi.fn().mockReturnValue(true),
+ *   set: vi.fn(),
+ *   entries: vi.fn(),
+ *   keys: vi.fn(),
+ *   values: vi.fn()
+ * };
+ *
+ * // Test form data operations
+ * mockFormData.append('file', new Blob(['content']));
+ * mockFormData.set('field', 'value');
+ * ```
  */
 export interface MockFormData {
-    /** Append field */
-    append: Vitest.MockInstance;
-    /** Delete field */
-    delete: Vitest.MockInstance;
-    /** Get field value */
-    get: Vitest.MockInstance;
-    /** Get all field values */
-    getAll: Vitest.MockInstance;
-    /** Check if field exists */
-    has: Vitest.MockInstance;
-    /** Set field value */
-    set: Vitest.MockInstance;
-    /** Iterate entries */
-    entries: Vitest.MockInstance;
-    /** Iterate keys */
-    keys: Vitest.MockInstance;
-    /** Iterate values */
-    values: Vitest.MockInstance;
+    append: Vitest.Mock;
+    delete: Vitest.Mock;
+    get: Vitest.Mock;
+    getAll: Vitest.Mock;
+    has: Vitest.Mock;
+    set: Vitest.Mock;
+    entries: Vitest.Mock;
+    keys: Vitest.Mock;
+    values: Vitest.Mock;
+    forEach: Vitest.Mock;
+    _entries: Map<string, Array<string | Blob>>;
 }
 /**
- * Vitest.MockInstance Axios implementation
- * @interface MockAxios
+ * Mock Axios implementation for testing HTTP requests.
+ * Provides mocked versions of all Axios methods and interceptors.
+ *
+ * @example
+ * ```typescript
+ * const mockAxios: MockAxios = {
+ *   get: vi.fn().mockResolvedValue({ data: { users: [] } }),
+ *   post: vi.fn().mockResolvedValue({ data: { id: 1 } }),
+ *   put: vi.fn().mockResolvedValue({ data: { updated: true } }),
+ *   patch: vi.fn().mockResolvedValue({ data: { patched: true } }),
+ *   delete: vi.fn().mockResolvedValue({ data: { deleted: true } }),
+ *   head: vi.fn().mockResolvedValue({ headers: {} }),
+ *   options: vi.fn().mockResolvedValue({ data: ['GET', 'POST'] }),
+ *   interceptors: {
+ *     request: { use: vi.fn(), eject: vi.fn() },
+ *     response: { use: vi.fn(), eject: vi.fn() }
+ *   }
+ * };
+ * ```
  */
 export interface MockAxios {
-    /** GET request */
-    get: Vitest.MockInstance;
-    /** POST request */
-    post: Vitest.MockInstance;
-    /** PUT request */
-    put: Vitest.MockInstance;
-    /** PATCH request */
-    patch: Vitest.MockInstance;
-    /** DELETE request */
-    delete: Vitest.MockInstance;
-    /** HEAD request */
-    head: Vitest.MockInstance;
-    /** OPTIONS request */
-    options: Vitest.MockInstance;
-    /** Request interceptors */
+    get: Vitest.Mock;
+    post: Vitest.Mock;
+    put: Vitest.Mock;
+    patch: Vitest.Mock;
+    delete: Vitest.Mock;
+    head: Vitest.Mock;
+    options: Vitest.Mock;
+    request: Vitest.Mock;
+    create: Vitest.Mock;
+    defaults: {
+        headers: {
+            common: Record<string, string>;
+            get: Record<string, string>;
+            post: Record<string, string>;
+            put: Record<string, string>;
+            patch: Record<string, string>;
+            delete: Record<string, string>;
+        };
+        baseURL?: string;
+        timeout?: number;
+        withCredentials?: boolean;
+    };
     interceptors: {
         request: {
-            use: Vitest.MockInstance;
-            eject: Vitest.MockInstance;
+            use: Vitest.Mock;
+            eject: Vitest.Mock;
+            handlers: Array<{
+                fulfilled: Function;
+                rejected?: Function;
+            }>;
         };
         response: {
-            use: Vitest.MockInstance;
-            eject: Vitest.MockInstance;
+            use: Vitest.Mock;
+            eject: Vitest.Mock;
+            handlers: Array<{
+                fulfilled: Function;
+                rejected?: Function;
+            }>;
         };
     };
+    mockResponse: Vitest.Mock;
+    mockError: Vitest.Mock;
+    mockResponseOnce: Vitest.Mock;
+    mockErrorOnce: Vitest.Mock;
+    reset: Vitest.Mock;
 }
 /**
- * Vitest.MockInstance Headers implementation
- * @interface MockHeaders
+ * Mock Headers implementation for testing HTTP headers.
+ * Simulates the Fetch API Headers interface.
+ *
+ * @example
+ * ```typescript
+ * const mockHeaders: MockHeaders = {
+ *   append: vi.fn(),
+ *   delete: vi.fn(),
+ *   get: vi.fn().mockReturnValue('application/json'),
+ *   has: vi.fn().mockReturnValue(true),
+ *   set: vi.fn(),
+ *   entries: vi.fn(),
+ *   keys: vi.fn(),
+ *   values: vi.fn()
+ * };
+ *
+ * // Test header operations
+ * mockHeaders.set('Content-Type', 'application/json');
+ * mockHeaders.append('Authorization', 'Bearer token');
+ * ```
  */
 export interface MockHeaders {
-    /** Append header */
-    append: Vitest.MockInstance;
-    /** Delete header */
-    delete: Vitest.MockInstance;
-    /** Get header value */
-    get: Vitest.MockInstance;
-    /** Check if header exists */
-    has: Vitest.MockInstance;
-    /** Set header value */
-    set: Vitest.MockInstance;
-    /** Iterate entries */
-    entries: Vitest.MockInstance;
-    /** Iterate keys */
-    keys: Vitest.MockInstance;
-    /** Iterate values */
-    values: Vitest.MockInstance;
+    append: Vitest.Mock;
+    delete: Vitest.Mock;
+    get: Vitest.Mock;
+    has: Vitest.Mock;
+    set: Vitest.Mock;
+    entries: Vitest.Mock;
+    keys: Vitest.Mock;
+    values: Vitest.Mock;
+    forEach: Vitest.Mock;
+    _headers: Map<string, string>;
 }
 /**
- * Vitest.MockInstance Cookie manager
- * @interface MockCookie
+ * Mock cookie manager for testing cookie operations.
+ * Provides methods for cookie manipulation in tests.
+ *
+ * @example
+ * ```typescript
+ * const mockCookie: MockCookie = {
+ *   get: vi.fn().mockReturnValue('sessionId=abc123'),
+ *   set: vi.fn(),
+ *   delete: vi.fn(),
+ *   getAll: vi.fn().mockReturnValue({ sessionId: 'abc123', theme: 'dark' }),
+ *   clear: vi.fn(),
+ *   parse: vi.fn().mockImplementation((str) => ({
+ *     sessionId: 'abc123'
+ *   })),
+ *   serialize: vi.fn().mockReturnValue('sessionId=abc123; Path=/; HttpOnly')
+ * };
+ * ```
  */
 export interface MockCookie {
-    /** Get cookie */
-    get: Vitest.MockInstance;
-    /** Set cookie */
-    set: Vitest.MockInstance;
-    /** Delete cookie */
-    delete: Vitest.MockInstance;
-    /** Get all cookies */
-    getAll: Vitest.MockInstance;
-    /** Clear cookies */
-    clear: Vitest.MockInstance;
-    /** Parse cookie string */
-    parse: Vitest.MockInstance;
-    /** Serialize cookie */
-    serialize: Vitest.MockInstance;
+    get: Vitest.Mock;
+    set: Vitest.Mock;
+    delete: Vitest.Mock;
+    clear: Vitest.Mock;
+    getAll: Vitest.Mock;
+    has: Vitest.Mock;
+    serialize: Vitest.Mock;
+    parse: Vitest.Mock;
+    _cookies: Map<string, {
+        value: string;
+        options?: unknown;
+    }>;
 }
 /**
- * Vitest.MockInstance Session implementation
- * @interface MockSession
+ * Mock session implementation for testing session management.
+ * Provides methods for session storage and lifecycle.
+ *
+ * @example
+ * ```typescript
+ * const mockSession: MockSession = {
+ *   get: vi.fn().mockReturnValue({ userId: '123' }),
+ *   set: vi.fn(),
+ *   delete: vi.fn(),
+ *   clear: vi.fn(),
+ *   save: vi.fn().mockResolvedValue(undefined),
+ *   destroy: vi.fn().mockResolvedValue(undefined),
+ *   touch: vi.fn()
+ * };
+ *
+ * // Test session operations
+ * mockSession.set('userId', '123');
+ * await mockSession.save();
+ * ```
  */
 export interface MockSession {
-    /** Get session value */
-    get: Vitest.MockInstance;
-    /** Set session value */
-    set: Vitest.MockInstance;
-    /** Delete session value */
-    delete: Vitest.MockInstance;
-    /** Clear session */
-    clear: Vitest.MockInstance;
-    /** Save session */
-    save: Vitest.MockInstance;
-    /** Destroy session */
-    destroy: Vitest.MockInstance;
-    /** Touch session */
-    touch: Vitest.MockInstance;
+    get: Vitest.Mock;
+    set: Vitest.Mock;
+    delete: Vitest.Mock;
+    clear: Vitest.Mock;
+    has: Vitest.Mock;
+    save: Vitest.Mock;
+    destroy: Vitest.Mock;
+    regenerate: Vitest.Mock;
+    touch: Vitest.Mock;
+    reload: Vitest.Mock;
+    id: string;
+    _data: Record<string, unknown>;
+    _dirty: boolean;
+    _destroyed: boolean;
 }
 /**
- * Vitest.MockInstance HTTP interceptor
- * @interface MockInterceptor
+ * Mock HTTP interceptor for testing request/response interception.
+ * Allows intercepting and modifying HTTP traffic in tests.
+ *
+ * @example
+ * ```typescript
+ * const mockInterceptor: MockInterceptor = {
+ *   intercept: vi.fn().mockReturnThis(),
+ *   capture: vi.fn().mockReturnThis(),
+ *   reply: vi.fn().mockImplementation((status, data) => ({ status, data })),
+ *   status: vi.fn().mockReturnThis(),
+ *   headers: vi.fn().mockReturnThis()
+ * };
+ *
+ * // Chain interceptor methods
+ * mockInterceptor
+ *   .intercept('/api/users')
+ *   .status(200)
+ *   .reply(200, { users: [] });
+ * ```
  */
 export interface MockInterceptor {
-    /** Intercept requests */
-    intercept: Vitest.MockInstance;
-    /** Capture requests */
-    capture: Vitest.MockInstance;
-    /** Reply to requests */
-    reply: Vitest.MockInstance;
-    /** Set status code */
-    status: Vitest.MockInstance;
-    /** Set headers */
-    headers: Vitest.MockInstance;
+    intercept: Vitest.Mock;
+    capture: Vitest.Mock;
+    reply: Vitest.Mock;
+    replyWithError: Vitest.Mock;
+    delay: Vitest.Mock;
+    times: Vitest.Mock;
+    persist: Vitest.Mock;
+    once: Vitest.Mock;
+    reset: Vitest.Mock;
+    isDone: Vitest.Mock;
+    _matches: Array<{
+        method: string;
+        path: string;
+        response?: unknown;
+        error?: Error;
+        delay?: number;
+        times?: number;
+        persistent?: boolean;
+    }>;
+    _captured: Array<{
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+        body?: unknown;
+        timestamp: number;
+    }>;
 }
 /**
- * Vitest.MockInstance OS module
- * @interface MockOS
+ * Mock OS module interface for testing OS-specific functionality.
+ * Provides mocked versions of Node.js OS module methods.
+ *
+ * @example
+ * ```typescript
+ * const mockOS: MockOS = {
+ *   platform: vi.fn(() => 'darwin'),
+ *   arch: vi.fn(() => 'x64'),
+ *   cpus: vi.fn(() => [{ model: 'Intel', speed: 2400 }]),
+ *   totalmem: vi.fn(() => 16000000000),
+ *   freemem: vi.fn(() => 8000000000),
+ *   hostname: vi.fn(() => 'test-machine'),
+ *   homedir: vi.fn(() => '/home/user'),
+ *   tmpdir: vi.fn(() => '/tmp')
+ * };
+ * ```
  */
 export interface MockOS {
-    /** Platform info */
-    platform: Vitest.MockInstance<() => string>;
-    /** Architecture info */
-    arch: Vitest.MockInstance<() => string>;
-    /** CPU information */
-    cpus: Vitest.MockInstance<() => unknown[]>;
-    /** Memory information */
-    totalmem: Vitest.MockInstance<() => number>;
-    /** Free memory */
-    freemem: Vitest.MockInstance<() => number>;
-    /** Hostname */
-    hostname: Vitest.MockInstance<() => string>;
-    /** Home directory */
-    homedir: Vitest.MockInstance<() => string>;
-    /** Temp directory */
-    tmpdir: Vitest.MockInstance<() => string>;
+    platform: Vitest.Mock<() => string>;
+    arch: Vitest.Mock<() => string>;
+    cpus: Vitest.Mock<() => unknown[]>;
+    totalmem: Vitest.Mock<() => number>;
+    freemem: Vitest.Mock<() => number>;
+    uptime: Vitest.Mock<() => number>;
+    loadavg: Vitest.Mock<() => number[]>;
+    hostname: Vitest.Mock<() => string>;
+    networkInterfaces: Vitest.Mock<() => unknown>;
+    userInfo: Vitest.Mock<() => unknown>;
+    type: Vitest.Mock<() => string>;
+    release: Vitest.Mock<() => string>;
+    version: Vitest.Mock<() => string>;
+    homedir: Vitest.Mock<() => string>;
+    tmpdir: Vitest.Mock<() => string>;
+    endianness: Vitest.Mock<() => string>;
+    EOL: string;
 }
 /**
- * Vitest.MockInstance Cluster module
- * @interface MockCluster
+ * Mock Cluster module interface for testing clustered Node.js applications.
+ * Provides mocked cluster management functionality.
+ *
+ * @example
+ * ```typescript
+ * const mockCluster: MockCluster = {
+ *   isPrimary: true,
+ *   isMaster: true,
+ *   isWorker: false,
+ *   workers: {},
+ *   fork: vi.fn().mockReturnValue({ id: 1, process: {} }),
+ *   setupPrimary: vi.fn(),
+ *   setupMaster: vi.fn(),
+ *   disconnect: vi.fn(),
+ *   settings: {},
+ *   schedulingPolicy: 2,
+ *   SCHED_NONE: 1,
+ *   SCHED_RR: 2
+ * };
+ * ```
  */
 export interface MockCluster {
-    /** Is primary process */
     isPrimary: boolean;
-    /** Is master process (deprecated) */
     isMaster: boolean;
-    /** Is worker process */
     isWorker: boolean;
-    /** Worker instance */
-    worker?: unknown;
-    /** All workers */
-    workers: Record<string, unknown>;
-    /** Fork new worker */
-    fork: Vitest.MockInstance;
-    /** Disconnect cluster */
-    disconnect: Vitest.MockInstance;
-    /** Setup master/primary */
-    setupMaster: Vitest.MockInstance;
+    workers: Record<number, unknown>;
+    fork: Vitest.Mock<(env?: unknown) => unknown>;
+    setupPrimary: Vitest.Mock<(settings?: unknown) => void>;
+    setupMaster: Vitest.Mock<(settings?: unknown) => void>;
+    on: Vitest.Mock;
+    once: Vitest.Mock;
+    removeListener: Vitest.Mock;
+    emit: Vitest.Mock;
+    disconnect: Vitest.Mock<(callback?: Function) => void>;
+    settings: unknown;
+    schedulingPolicy: number;
+    SCHED_NONE: number;
+    SCHED_RR: number;
 }
 /**
- * Event listener removal parameters
- * @interface RemoveListenerParams
+ * Parameters for removing event listeners from event emitters.
+ * Used internally for event listener management.
+ *
+ * @example
+ * ```typescript
+ * const params: RemoveListenerParams = {
+ *   events: new Map([['click', new Set([handler1, handler2])]]),
+ *   onceEvents: new Map([['load', new Set([onceHandler])]]),
+ *   event: 'click',
+ *   listener: handler1,
+ *   emitter: mockEventEmitter
+ * };
+ * ```
  */
 export interface RemoveListenerParams {
-    /** Event listeners map */
     events: Map<string | symbol, Set<Function>>;
-    /** Once listeners map */
     onceEvents: Map<string | symbol, Set<Function>>;
-    /** Event name */
     event: string | symbol;
-    /** Listener function */
     listener: Function;
+    emitter: MockEventEmitter;
 }
 /**
- * Vitest.MockInstance File Watcher
- * @interface MockFileWatcher
+ * Mock file watcher interface for testing file system monitoring.
+ * Simulates file watching behavior for testing file change events.
+ *
+ * @example
+ * ```typescript
+ * const watcher: MockFileWatcher = {
+ *   on: vi.fn(),
+ *   off: vi.fn(),
+ *   emit: vi.fn(),
+ *   close: vi.fn(),
+ *   simulateChange: (eventType, filename) => {
+ *     watcher.emit(eventType, filename);
+ *   },
+ *   isWatching: () => true,
+ *   getListenerCount: (event) => 2,
+ *   getAllListeners: () => new Map()
+ * };
+ *
+ * // Simulate file change
+ * watcher.simulateChange('change', 'file.txt');
+ * ```
  */
 export interface MockFileWatcher {
-    /** Add event listener */
     on: ReturnType<typeof Vitest.vi.fn>;
-    /** Remove event listener */
     off: ReturnType<typeof Vitest.vi.fn>;
-    /** Emit event */
     emit: ReturnType<typeof Vitest.vi.fn>;
-    /** Close watcher */
     close: ReturnType<typeof Vitest.vi.fn>;
-    /** Unref watcher */
-    unref: ReturnType<typeof Vitest.vi.fn>;
+    simulateChange: (eventType: string, filename?: string) => void;
+    isWatching: () => boolean;
+    getListenerCount: (event: string) => number;
+    getAllListeners: () => Map<string, Set<(...args: unknown[]) => void>>;
 }
 /**
- * Console mock parameters
- * @interface ConsoleMockParams
+ * Parameters for configuring console mocking behavior.
+ * Controls how console methods are intercepted and stored.
+ *
+ * @example
+ * ```typescript
+ * const params: ConsoleMockParams = {
+ *   type: 'log',
+ *   storage: [],
+ *   all: [],
+ *   originalFn: console.log,
+ *   suppressTypes: ['debug'],
+ *   formatArguments: (args) => args.join(' '),
+ *   captureStackTrace: false
+ * };
+ * ```
  */
 export interface ConsoleMockParams {
-    /** Console method type */
     type: string;
-    /** Storage array */
     storage: string[];
-    /** All calls */
     all: Array<{
         type: string;
         args: unknown[];
     }>;
+    originalFn: Function;
+    suppressTypes: string[];
+    formatArguments: (args: unknown[]) => string;
+    captureStackTrace?: boolean;
 }
 /**
- * Vitest.MockInstance Buffer implementation
- * @interface MockBuffer
+ * Mock Buffer implementation for testing buffer operations.
+ * Provides mocked versions of Node.js Buffer static methods.
+ *
+ * @example
+ * ```typescript
+ * const mockBuffer: MockBuffer = {
+ *   from: vi.fn().mockImplementation((data) => Buffer.from(data)),
+ *   alloc: vi.fn().mockImplementation((size) => Buffer.alloc(size)),
+ *   allocUnsafe: vi.fn().mockImplementation((size) => Buffer.allocUnsafe(size)),
+ *   concat: vi.fn().mockImplementation((list) => Buffer.concat(list)),
+ *   isBuffer: vi.fn().mockReturnValue(true),
+ *   byteLength: vi.fn().mockReturnValue(10),
+ *   compare: vi.fn().mockReturnValue(0),
+ *   isEncoding: vi.fn().mockReturnValue(true)
+ * };
+ * ```
  */
 export interface MockBuffer {
-    /** Create buffer from data */
-    from: Vitest.MockInstance;
-    /** Allocate buffer */
-    alloc: Vitest.MockInstance;
-    /** Allocate unsafe buffer */
-    allocUnsafe: Vitest.MockInstance;
-    /** Concatenate buffers */
-    concat: Vitest.MockInstance;
-    /** Compare buffers */
-    compare: Vitest.MockInstance;
+    from: Vitest.Mock;
+    alloc: Vitest.Mock;
+    allocUnsafe: Vitest.Mock;
+    concat: Vitest.Mock;
+    isBuffer: Vitest.Mock;
+    byteLength: Vitest.Mock;
+    compare: Vitest.Mock;
+    isEncoding: Vitest.Mock;
 }
 /**
- * Vitest.MockInstance Worker Threads
- * @interface MockWorkerThreads
+ * Mock Worker Threads interface for testing multi-threaded Node.js applications.
+ * Provides mocked worker thread functionality.
+ *
+ * @example
+ * ```typescript
+ * const mockWorkerThreads: MockWorkerThreads = {
+ *   Worker: vi.fn().mockImplementation(() => ({
+ *     postMessage: vi.fn(),
+ *     terminate: vi.fn()
+ *   })),
+ *   isMainThread: true,
+ *   parentPort: null,
+ *   workerData: { task: 'process' },
+ *   threadId: 0,
+ *   resourceLimits: {},
+ *   getEnvironmentData: vi.fn(),
+ *   setEnvironmentData: vi.fn(),
+ *   SHARE_ENV: Symbol('SHARE_ENV'),
+ *   markAsUntransferable: vi.fn(),
+ *   moveMessagePortToContext: vi.fn(),
+ *   receiveMessageOnPort: vi.fn()
+ * };
+ * ```
  */
 export interface MockWorkerThreads {
-    /** Worker constructor */
-    Worker: Vitest.MockInstance;
-    /** Is main thread */
+    Worker: Vitest.Mock;
     isMainThread: boolean;
-    /** Parent port */
     parentPort: unknown;
-    /** Worker data */
     workerData: unknown;
-    /** Thread ID */
     threadId: number;
+    resourceLimits: Record<string, unknown>;
+    getEnvironmentData: Vitest.Mock<() => unknown>;
+    setEnvironmentData: Vitest.Mock<(key: string, value: unknown) => void>;
+    SHARE_ENV: symbol;
+    markAsUntransferable: Vitest.Mock<(obj: unknown) => void>;
+    moveMessagePortToContext: Vitest.Mock<(port: unknown, context: unknown) => unknown>;
+    receiveMessageOnPort: Vitest.Mock<(port: unknown) => unknown>;
 }