@plyaz/types 1.3.2 → 1.3.3

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

@@ -0,0 +1,1662 @@
+/**
+ * @fileoverview Mock Types and Interfaces
+ *
+ * Comprehensive type definitions for mock objects used throughout the testing suite.
+ * Provides type-safe interfaces for mocking Node.js APIs, browser APIs, framework
+ * components, and external dependencies.
+ *
+ * This module includes mock types for:
+ * - File system operations (fs module)
+ * - Process and environment APIs
+ * - HTTP requests and responses
+ * - Next.js components and APIs
+ * - Browser APIs (WebSocket, EventEmitter)
+ * - Database and external services
+ * - Testing framework utilities
+ *
+ * @example
+ * ```typescript
+ * import type { MockFS, MockNextRouter, MockEventEmitter } from './types';
+ *
+ * // File system mocking
+ * const mockFS: MockFS = createMockFS();
+ * mockFS.readFileSync.mockReturnValue('test content');
+ *
+ * // Next.js router mocking
+ * const mockRouter: MockNextRouter = createMockNextRouter({
+ *   pathname: '/test',
+ *   query: { id: '123' }
+ * });
+ *
+ * // Event emitter mocking
+ * const mockEmitter: MockEventEmitter = createMockEventEmitter();
+ * mockEmitter.on('test', handler);
+ * ```
+ *
+ * @module MockTypes
+ * @since 1.0.0
+ */
+import type * as Vitest from 'vitest';
+import type * as React from 'react';
+import type * as Next from 'next';
+import type * as NextRouter from 'next/router';
+import type * as NextImage from 'next/image';
+import type * as NextLink from 'next/link';
+/**
+ * Mock file system interface matching Node.js fs module
+ *
+ * @example
+ * ```typescript
+ * const mockFS: MockFS = createMockFS();
+ *
+ * // Mock file operations
+ * mockFS.readFileSync.mockReturnValue('file content');
+ * mockFS.existsSync.mockReturnValue(true);
+ * ```
+ */
+export interface MockFS {
+    /** Async read file */
+    readFile: Vitest.Mock;
+    /** Async write file */
+    writeFile: Vitest.Mock;
+    /** Sync read file */
+    readFileSync: Vitest.Mock;
+    /** Sync write file */
+    writeFileSync: Vitest.Mock;
+    /** Check if path exists */
+    existsSync: Vitest.Mock;
+    /** Create directory */
+    mkdirSync: Vitest.Mock;
+    /** Read directory contents */
+    readdirSync: Vitest.Mock;
+    /** Get file stats */
+    statSync: Vitest.Mock;
+    /** Delete file */
+    unlinkSync: Vitest.Mock;
+    /** Remove file or directory */
+    rmSync: Vitest.Mock;
+}
+/**
+ * Mock process interface matching Node.js process global
+ *
+ * @example
+ * ```typescript
+ * const mockProcess: Vitest.MockProcess = createMockProcess();
+ *
+ * // Mock environment
+ * mockProcess.env.NODE_ENV = 'test';
+ *
+ * // Mock process exit
+ * mockProcess.exit.mockImplementation((code) => {
+ *   throw new Error(`Process exited with code ${code}`);
+ * });
+ * ```
+ */
+export interface MockProcess {
+    /** Environment variables */
+    env: Record<string, string | undefined>;
+    /** Exit the process */
+    exit: Vitest.Mock;
+    /** Get current working directory */
+    cwd: Vitest.Mock;
+    /** Change current directory */
+    chdir: Vitest.Mock;
+    /** Standard output stream */
+    stdout: {
+        /** Write to stdout */
+        write: Vitest.Mock;
+    };
+    /** Standard error stream */
+    stderr: {
+        /** Write to stderr */
+        write: Vitest.Mock;
+    };
+    /** Add event listener */
+    on: Vitest.Mock;
+    /** Remove event listener */
+    removeListener: Vitest.Mock;
+}
+/**
+ * Mock crypto interface matching Node.js crypto module
+ *
+ * @example
+ * ```typescript
+ * const mockCrypto: MockCrypto = createMockCrypto();
+ *
+ * // Mock UUID generation
+ * mockCrypto.randomUUID.mockReturnValue('123e4567-e89b-12d3-a456-426614174000');
+ *
+ * // Mock hashing
+ * mockCrypto.createHash.mockReturnValue({
+ *   update: vi.fn().mockReturnThis(),
+ *   digest: vi.fn().mockReturnValue('hash-value')
+ * });
+ * ```
+ */
+export interface MockCrypto {
+    /** Generate random bytes */
+    randomBytes: Vitest.Mock;
+    /** Generate random UUID */
+    randomUUID: Vitest.Mock;
+    /** Create hash object */
+    createHash: Vitest.Mock;
+    /** Create HMAC object */
+    createHmac: Vitest.Mock;
+}
+/**
+ * Mock path interface matching Node.js path module
+ *
+ * @example
+ * ```typescript
+ * const mockPath: MockPath = createMockPath();
+ *
+ * // Mock path operations
+ * mockPath.join.mockReturnValue('/path/to/file');
+ * mockPath.dirname.mockReturnValue('/path/to');
+ * mockPath.extname.mockReturnValue('.js');
+ * ```
+ */
+export interface MockPath {
+    /** Join path segments */
+    join: Vitest.Mock;
+    /** Resolve absolute path */
+    resolve: Vitest.Mock;
+    /** Get directory name */
+    dirname: Vitest.Mock;
+    /** Get base name */
+    basename: Vitest.Mock;
+    /** Get file extension */
+    extname: Vitest.Mock;
+    /** Get relative path */
+    relative: Vitest.Mock;
+    /** Check if path is absolute */
+    isAbsolute: Vitest.Mock;
+    /** Normalize path */
+    normalize: Vitest.Mock;
+    /** Path separator for platform */
+    sep: string;
+}
+/**
+ * Mock child process interface matching Node.js child_process module
+ *
+ * @example
+ * ```typescript
+ * const mockChildProcess: MockChildProcess = createMockChildProcess();
+ *
+ * // Mock spawning processes
+ * mockChildProcess.spawn.mockReturnValue(mockProcess);
+ * mockChildProcess.exec.mockImplementation((cmd, callback) => {
+ *   callback(null, 'output', '');
+ * });
+ * ```
+ */
+export interface MockChildProcess {
+    /** Spawn a new process */
+    spawn: Vitest.Mock;
+    /** Execute command asynchronously */
+    exec: Vitest.Mock;
+    /** Execute command synchronously */
+    execSync: Vitest.Mock;
+    /** Fork a child process */
+    fork: Vitest.Mock;
+}
+/**
+ * Mock timers interface for testing time-dependent code
+ *
+ * @example
+ * ```typescript
+ * const timers: MockTimers = createMockTimers();
+ *
+ * // Use fake timers in test
+ * timers.useFakeTimers();
+ *
+ * // Schedule and advance time
+ * const timeoutId = timers.setTimeout(callback, 1000);
+ * timers.advanceTimersByTime(1000);
+ *
+ * // Clean up
+ * timers.useRealTimers();
+ * ```
+ */
+export interface MockTimers {
+    /** Schedule a timeout */
+    setTimeout: Vitest.Mock;
+    /** Clear a timeout */
+    clearTimeout: Vitest.Mock;
+    /** Schedule an interval */
+    setInterval: Vitest.Mock;
+    /** Clear an interval */
+    clearInterval: Vitest.Mock;
+    /** Schedule immediate execution */
+    setImmediate: Vitest.Mock;
+    /** Clear immediate execution */
+    clearImmediate: Vitest.Mock;
+    /** Enable fake timers */
+    useFakeTimers: () => void;
+    /** Restore real timers */
+    useRealTimers: () => void;
+    /** Advance fake timers by milliseconds */
+    advanceTimersByTime: (ms: number) => void;
+    /** Run all pending timers */
+    runAllTimers: () => void;
+    /** Run only currently pending timers */
+    runOnlyPendingTimers: () => void;
+    /** Clear all active timers */
+    clearAllTimers: () => void;
+    /** Get count of active timers */
+    getTimerCount: () => number;
+}
+/**
+ * Mock EventEmitter interface matching Node.js EventEmitter
+ *
+ * @example
+ * ```typescript
+ * const emitter: MockEventEmitter = createMockEventEmitter();
+ *
+ * // Mock event handling
+ * emitter.on.mockImplementation((event, listener) => {
+ *   // Store listener for later emission
+ * });
+ *
+ * emitter.emit.mockImplementation((event, ...args) => {
+ *   // Call stored listeners
+ * });
+ * ```
+ */
+export interface MockEventEmitter {
+    /** Add event listener */
+    on: Vitest.Mock;
+    /** Add one-time event listener */
+    once: Vitest.Mock;
+    /** Remove event listener */
+    off: Vitest.Mock;
+    /** Emit event to listeners */
+    emit: Vitest.Mock;
+    /** Emit event asynchronously */
+    emitAsync: Vitest.Mock;
+    /** Remove specific listener */
+    removeListener: Vitest.Mock;
+    /** Remove all listeners for event */
+    removeAllListeners: Vitest.Mock;
+    /** Alias for on() */
+    addListener: Vitest.Mock;
+    /** Get listeners for event */
+    listeners: Vitest.Mock;
+    /** Count listeners for event */
+    listenerCount: Vitest.Mock;
+    /** Get all event names */
+    eventNames: Vitest.Mock;
+    /** Set max listeners limit */
+    setMaxListeners: Vitest.Mock;
+    /** Get max listeners limit */
+    getMaxListeners: Vitest.Mock;
+    /** Wait for specific event */
+    waitForEvent: Vitest.Mock;
+    /** Get raw listeners array */
+    rawListeners: Vitest.Mock;
+    /** Prepend listener to start of list */
+    prependListener: Vitest.Mock;
+    /** Prepend one-time listener */
+    prependOnceListener: Vitest.Mock;
+}
+/**
+ * Mock logger interface matching NestJS Logger methods
+ *
+ * @example
+ * ```typescript
+ * const logger: MockLogger = createMockLogger();
+ *
+ * // Mock logging methods
+ * logger.log.mockImplementation((message) => {
+ *   console.log(`[LOG] ${message}`);
+ * });
+ *
+ * logger.error.mockImplementation((message, trace) => {
+ *   console.error(`[ERROR] ${message}`, trace);
+ * });
+ * ```
+ */
+export interface MockLogger {
+    /** Log info message */
+    log: Vitest.Mock;
+    /** Log error message */
+    error: Vitest.Mock;
+    /** Log warning message */
+    warn: Vitest.Mock;
+    /** Log info message */
+    info: Vitest.Mock;
+    /** Log debug message */
+    debug: Vitest.Mock;
+    /** Log verbose message */
+    verbose: Vitest.Mock;
+    /** Set log level */
+    setLevel: Vitest.Mock;
+    /** Get log level */
+    getLevel: Vitest.Mock;
+}
+/**
+ * NestJS common decorators and exceptions mock interface
+ *
+ * @example
+ * ```typescript
+ * const nestjsMocks: NestJsCommonMocks = createNestJsMocks();
+ *
+ * // Mock decorators
+ * nestjsMocks.Injectable.mockReturnValue(() => {});
+ * nestjsMocks.Inject.mockReturnValue(() => {});
+ *
+ * // Mock exceptions
+ * nestjsMocks.NotFoundException.mockImplementation((message) => {
+ *   const error = new Error(message);
+ *   (error as any).status = 404;
+ *   return error;
+ * });
+ * ```
+ */
+export interface NestJsCommonMocks {
+    /** Injectable decorator mock */
+    Injectable: Vitest.Mock;
+    /** Inject decorator mock */
+    Inject: Vitest.Mock;
+    /** Optional decorator mock */
+    Optional: Vitest.Mock;
+    /** Logger class mock */
+    Logger: Vitest.Mock;
+    /** HttpException class mock */
+    HttpException: Vitest.Mock;
+    /** HTTP status codes */
+    HttpStatus: Record<string, number>;
+    /** BadRequestException class mock */
+    BadRequestException: Vitest.Mock;
+    /** NotFoundException class mock */
+    NotFoundException: Vitest.Mock;
+    /** UnauthorizedException class mock */
+    UnauthorizedException: Vitest.Mock;
+    /** ForbiddenException class mock */
+    ForbiddenException: Vitest.Mock;
+    /** InternalServerErrorException class mock */
+    InternalServerErrorException: Vitest.Mock;
+}
+/**
+ * Mock CRUD service interface for testing data operations
+ *
+ * @example
+ * ```typescript
+ * const crudService: CrudServiceMock = createCrudServiceMock();
+ *
+ * // Mock CRUD operations
+ * crudService.findAll.mockResolvedValue([{ id: 1, name: 'test' }]);
+ * crudService.findOne.mockResolvedValue({ id: 1, name: 'test' });
+ * crudService.create.mockResolvedValue({ id: 2, name: 'new' });
+ * ```
+ */
+export interface CrudServiceMock {
+    /** Find all entities */
+    findAll: Vitest.Mock;
+    /** Find one entity */
+    findOne: Vitest.Mock;
+    /** Create new entity */
+    create: Vitest.Mock;
+    /** Update existing entity */
+    update: Vitest.Mock;
+    /** Remove entity */
+    remove: Vitest.Mock;
+}
+/**
+ * Mock NestJS testing module interface
+ *
+ * @example
+ * ```typescript
+ * const module: MockTestingModule = createMockTestingModule();
+ *
+ * // Get service from module
+ * const service = module.get(ServiceToken);
+ *
+ * // Resolve async service
+ * const asyncService = await module.resolve(AsyncServiceToken);
+ *
+ * // Clean up
+ * await module.close();
+ * ```
+ */
+export interface MockTestingModule {
+    /** Get service by token */
+    get<T>(token: unknown): T;
+    /** Resolve service asynchronously */
+    resolve<T>(token: unknown): Promise<T>;
+    /** Close and clean up module */
+    close(): Promise<void>;
+}
+/**
+ * HttpException error type for testing NestJS HTTP errors
+ *
+ * @example
+ * ```typescript
+ * const error: HttpExceptionError = {
+ *   name: 'HttpException',
+ *   message: 'Not found',
+ *   status: 404,
+ *   response: 'User not found',
+ *   getStatus: () => 404,
+ *   getResponse: () => 'User not found'
+ * };
+ * ```
+ */
+export type HttpExceptionError = Error & {
+    /** HTTP status code */
+    status: number;
+    /** Error response data */
+    response: string | object;
+    /** Get HTTP status code */
+    getStatus: () => number;
+    /** Get error response */
+    getResponse: () => string | object;
+};
+/**
+ * Simple exception error type for basic error testing
+ *
+ * @example
+ * ```typescript
+ * const error: SimpleExceptionError = {
+ *   name: 'ValidationError',
+ *   message: 'Invalid input',
+ *   status: 400,
+ *   response: { field: 'email', message: 'Invalid format' }
+ * };
+ * ```
+ */
+export type SimpleExceptionError = Error & {
+    /** Error status code */
+    status: number;
+    /** Error response data */
+    response: unknown;
+};
+/**
+ * Mock React context value interface
+ *
+ * @typeParam T - Type of the context value
+ *
+ * @example
+ * ```typescript
+ * const contextValue: MockContextValue<User> = {
+ *   value: { id: 1, name: 'John' },
+ *   setValue: vi.fn((newValue) => {
+ *     contextValue.value = newValue;
+ *   })
+ * };
+ * ```
+ */
+export interface MockContextValue<T = unknown> {
+    /** Current context value */
+    value: T;
+    /** Function to update context value */
+    setValue: Vitest.Mock;
+}
+/**
+ * Mock React context provider interface
+ *
+ * @typeParam T - Type of the provider value
+ *
+ * @example
+ * ```typescript
+ * const mockProvider: MockProvider<Theme> = createMockProvider({
+ *   mode: 'light',
+ *   toggleMode: vi.fn()
+ * });
+ *
+ * // Use in test
+ * render(
+ *   <mockProvider.Provider value={mockProvider.value}>
+ *     <ThemedComponent />
+ *   </mockProvider.Provider>
+ * );
+ * ```
+ */
+export interface MockProvider<T = unknown> {
+    /** Provider component */
+    Provider: React.ComponentType<{
+        children: React.ReactNode;
+        value?: T;
+    }>;
+    /** Consumer component */
+    Consumer: React.ComponentType<{
+        children: (value: T) => React.ReactNode;
+    }>;
+    /** Current provider value */
+    value: T;
+    /** Function to update provider value */
+    updateValue: (newValue: T) => void;
+}
+/**
+ * Mock router interface for testing navigation
+ *
+ * @example
+ * ```typescript
+ * const router: MockRouter = createMockRouter();
+ *
+ * // Mock navigation
+ * router.push.mockResolvedValue(true);
+ * router.pathname = '/users';
+ * router.query = { id: '123' };
+ *
+ * // Test navigation
+ * await router.push('/users/456');
+ * expect(router.push).toHaveBeenCalledWith('/users/456');
+ * ```
+ */
+export interface MockRouter {
+    /** Navigate to new route */
+    push: Vitest.Mock;
+    /** Replace current route */
+    replace: Vitest.Mock;
+    /** Go back in history */
+    back: Vitest.Mock;
+    /** Go forward in history */
+    forward: Vitest.Mock;
+    /** Refresh current page */
+    refresh: Vitest.Mock;
+    /** Prefetch route */
+    prefetch: Vitest.Mock;
+    /** Current pathname */
+    pathname: string;
+    /** Query parameters */
+    query: Record<string, string | string[]>;
+    /** Full path with query */
+    asPath: string;
+    /** Navigate by delta in history */
+    go: (delta: number) => void;
+    /** Current location */
+    location: {
+        /** Current pathname */
+        pathname: string;
+        /** Search string */
+        search: string;
+        /** Hash fragment */
+        hash: string;
+        /** Router state */
+        state: unknown;
+    };
+    /** Navigation history */
+    history: Array<HistoryEntry>;
+}
+/**
+ * Mock React hooks interface for testing hook behavior
+ *
+ * @example
+ * ```typescript
+ * const hooks: MockHooks = createMockHooks();
+ *
+ * // Mock useState
+ * hooks.useState.mockReturnValue([initialValue, mockSetter]);
+ *
+ * // Mock useEffect
+ * hooks.useEffect.mockImplementation((effect, deps) => {
+ *   // Mock effect execution
+ * });
+ * ```
+ */
+export interface MockHooks {
+    /** Mock useState hook */
+    useState: Vitest.Mock;
+    /** Mock useEffect hook */
+    useEffect: Vitest.Mock;
+    /** Mock useContext hook */
+    useContext: Vitest.Mock;
+    /** Mock useReducer hook */
+    useReducer: Vitest.Mock;
+    /** Mock useCallback hook */
+    useCallback: Vitest.Mock;
+    /** Mock useMemo hook */
+    useMemo: Vitest.Mock;
+    /** Mock useRef hook */
+    useRef: Vitest.Mock;
+    /** Mock useLayoutEffect hook */
+    useLayoutEffect: Vitest.Mock;
+}
+/**
+ * Mock fetch interface for testing HTTP requests
+ *
+ * @example
+ * ```typescript
+ * const fetchMock: MockFetch = createMockFetch();
+ *
+ * // Mock successful response
+ * fetchMock.mockResponse({ data: 'test' }, { status: 200 });
+ *
+ * // Mock error
+ * fetchMock.mockError(new Error('Network error'));
+ *
+ * // Mock one-time response
+ * fetchMock.mockOnce({ id: 1 });
+ * ```
+ */
+export interface MockFetch {
+    /** Main fetch mock function */
+    mock: Vitest.Mock;
+    /** Mock successful response */
+    mockResponse: (response: unknown, options?: ResponseInit) => void;
+    /** Mock error response */
+    mockError: (error: Error) => void;
+    /** Mock response for next call only */
+    mockOnce: (response: unknown, options?: ResponseInit) => void;
+    /** Reset all mocks */
+    reset: () => void;
+}
+/**
+ * Mock localStorage interface for testing browser storage
+ *
+ * @example
+ * ```typescript
+ * const storage: MockLocalStorage = createMockLocalStorage();
+ *
+ * // Mock storage operations
+ * storage.getItem.mockReturnValue('stored-value');
+ * storage.setItem.mockImplementation((key, value) => {
+ *   // Store value
+ * });
+ *
+ * storage.length = 5;
+ * ```
+ */
+export interface MockLocalStorage {
+    /** Get item from storage */
+    getItem: Vitest.Mock;
+    /** Set item in storage */
+    setItem: Vitest.Mock;
+    /** Remove item from storage */
+    removeItem: Vitest.Mock;
+    /** Clear all storage */
+    clear: Vitest.Mock;
+    /** Number of items in storage */
+    length: number;
+    /** Get key at index */
+    key: Vitest.Mock;
+}
+/**
+ * Mock IntersectionObserver instance interface
+ *
+ * @example
+ * ```typescript
+ * const observer: MockIntersectionObserverInstance = {
+ *   callback: vi.fn(),
+ *   options: { threshold: 0.5 },
+ *   elements: new Set(),
+ *   observe: vi.fn(),
+ *   unobserve: vi.fn(),
+ *   disconnect: vi.fn(),
+ *   trigger: (entries) => observer.callback(entries, observer)
+ * };
+ * ```
+ */
+export interface MockIntersectionObserverInstance {
+    /** Observer callback function */
+    callback: IntersectionObserverCallback;
+    /** Observer configuration options */
+    options?: IntersectionObserverInit;
+    /** Set of observed elements */
+    elements: Set<Element>;
+    /** Start observing element */
+    observe: Vitest.Mock;
+    /** Stop observing element */
+    unobserve: Vitest.Mock;
+    /** Disconnect all observations */
+    disconnect: Vitest.Mock;
+    /** Manually trigger intersection entries */
+    trigger: (entries: IntersectionObserverEntry[]) => void;
+}
+/**
+ * Mock IntersectionObserver interface for testing viewport intersections
+ *
+ * @example
+ * ```typescript
+ * const observerMock: MockIntersectionObserver = createMockIntersectionObserver();
+ *
+ * // Trigger intersection for all observed elements
+ * observerMock.triggerAll(true);
+ *
+ * // Trigger specific intersection entries
+ * observerMock.triggerIntersect([
+ *   { isIntersecting: true, target: element }
+ * ]);
+ * ```
+ */
+export interface MockIntersectionObserver {
+    /** IntersectionObserver constructor mock */
+    MockIntersectionObserver: Vitest.Mock;
+    /** Array of observer instances */
+    instances: MockIntersectionObserverInstance[];
+    /** Trigger intersection for specific entries */
+    triggerIntersect: (entries: IntersectionObserverEntry[]) => void;
+    /** Trigger intersection for all observed elements */
+    triggerAll: (isIntersecting: boolean) => void;
+    /** Reset all observers */
+    reset: () => void;
+    /** Observe element mock */
+    observe: Vitest.Mock;
+    /** Unobserve element mock */
+    unobserve: Vitest.Mock;
+    /** Disconnect observer mock */
+    disconnect: Vitest.Mock;
+    /** Current observer callback */
+    callback: ((entries: IntersectionObserverEntry[]) => void) | null;
+}
+/**
+ * Mock Next.js router interface extending NextRouter with mock functions
+ *
+ * @example
+ * ```typescript
+ * const router: MockNextRouter = createMockNextRouter();
+ *
+ * // Mock router methods
+ * router.push.mockResolvedValue(true);
+ * router.events.on.mockImplementation((event, handler) => {
+ *   // Store event handler
+ * });
+ *
+ * // Test navigation
+ * await router.push('/new-page');
+ * ```
+ */
+export interface MockNextRouter extends Omit<NextRouter.NextRouter, 'push' | 'replace' | 'reload' | 'back' | 'forward' | 'prefetch' | 'beforePopState' | 'events'> {
+    /** Navigate to new route */
+    push: Vitest.Mock;
+    /** Replace current route */
+    replace: Vitest.Mock;
+    /** Reload current page */
+    reload: Vitest.Mock;
+    /** Go back in history */
+    back: Vitest.Mock;
+    /** Go forward in history */
+    forward: Vitest.Mock;
+    /** Prefetch route */
+    prefetch: Vitest.Mock;
+    /** Set before pop state handler */
+    beforePopState: Vitest.Mock;
+    /** Router events */
+    events: {
+        /** Add event listener */
+        on: Vitest.Mock;
+        /** Remove event listener */
+        off: Vitest.Mock;
+        /** Emit router event */
+        emit: Vitest.Mock;
+    };
+    pathname: string;
+    route: string;
+    query: Record<string, string | string[]>;
+    asPath: string;
+    basePath: string;
+    locale?: string;
+    locales?: string[];
+    defaultLocale?: string;
+    isReady: boolean;
+    isPreview: boolean;
+    isFallback: boolean;
+}
+/**
+ * Mock Next.js Link component props extending NextLink.LinkProps
+ *
+ * @example
+ * ```typescript
+ * const linkProps: MockNextLink = {
+ *   href: '/about',
+ *   children: 'About Page'
+ * };
+ *
+ * render(<MockLink {...linkProps} />);
+ * ```
+ */
+export type MockNextLink = NextLink.LinkProps & {
+    /** Link content */
+    children: React.ReactElement | string;
+};
+/**
+ * Mock Next.js API request extending Next.NextApiRequest for testing
+ *
+ * @example
+ * ```typescript
+ * const req: MockNextApiRequest = {
+ *   method: 'POST',
+ *   headers: { 'content-type': 'application/json' },
+ *   query: { id: '123' },
+ *   body: { name: 'test' },
+ *   cookies: { session: 'abc123' },
+ *   env: { NODE_ENV: 'test' }
+ * };
+ * ```
+ */
+export type MockNextApiRequest = Partial<Next.NextApiRequest> & {
+    /** Request headers */
+    headers: Record<string, string | string[]>;
+    /** Query parameters */
+    query: Record<string, string | string[]>;
+    /** Request body */
+    body: unknown;
+    /** Request cookies */
+    cookies: Record<string, string>;
+    /** Environment variables */
+    env: Record<string, string | undefined>;
+};
+/**
+ * Mock Next.js API response interface for testing
+ *
+ * @example
+ * ```typescript
+ * const res: MockNextApiResponse = createMockNextApiResponse();
+ *
+ * // Mock response methods
+ * res.status.mockReturnThis();
+ * res.json.mockReturnThis();
+ *
+ * // Test API response
+ * res.status(200).json({ success: true });
+ * expect(res.statusCode).toBe(200);
+ * ```
+ */
+export interface MockNextApiResponse {
+    /** Set response status */
+    status: Vitest.Mock;
+    /** Send JSON response */
+    json: Vitest.Mock;
+    /** Send response */
+    send: Vitest.Mock;
+    /** Redirect response */
+    redirect: Vitest.Mock;
+    /** Set response header */
+    setHeader: Vitest.Mock;
+    /** Get response header */
+    getHeader: Vitest.Mock;
+    /** Remove response header */
+    removeHeader: Vitest.Mock;
+    /** Write to response */
+    write: Vitest.Mock;
+    /** End response */
+    end: Vitest.Mock;
+    /** Current status code */
+    statusCode: number;
+    /** Current status message */
+    statusMessage: string;
+}
+/**
+ * Mock Next.js Next.GetServerSidePropsContext with mock request/response
+ *
+ * @example
+ * ```typescript
+ * const context: MockGetServerSidePropsContext = {
+ *   req: mockRequest,
+ *   res: mockResponse,
+ *   query: { id: '123' },
+ *   params: { slug: 'test' }
+ * };
+ *
+ * const result = await getServerSideProps(context);
+ * ```
+ */
+export type MockGetServerSidePropsContext = Omit<Next.GetServerSidePropsContext, 'req' | 'res'> & {
+    /** Mock request object */
+    req: MockNextApiRequest;
+    /** Mock response object */
+    res: MockNextApiResponse;
+};
+/**
+ * Mock Next.js Next.GetStaticPropsContext using Next.js type directly
+ *
+ * @example
+ * ```typescript
+ * const context: MockGetStaticPropsContext = {
+ *   params: { slug: 'test' },
+ *   preview: false,
+ *   previewData: undefined
+ * };
+ *
+ * const result = await getStaticProps(context);
+ * ```
+ */
+export type MockGetStaticPropsContext = Next.GetStaticPropsContext;
+/**
+ * Mock URLSearchParams interface for testing URL parameters
+ *
+ * @example
+ * ```typescript
+ * const searchParams: MockSearchParams = createMockSearchParams();
+ *
+ * // Mock search parameter operations
+ * searchParams.get.mockReturnValue('value');
+ * searchParams.has.mockReturnValue(true);
+ * searchParams.getAll.mockReturnValue(['value1', 'value2']);
+ * ```
+ */
+export interface MockSearchParams {
+    /** Get parameter value */
+    get: Vitest.Mock;
+    /** Get all values for parameter */
+    getAll: Vitest.Mock;
+    /** Check if parameter exists */
+    has: Vitest.Mock;
+    /** Get all parameter keys */
+    keys: Vitest.Mock;
+    /** Get all parameter values */
+    values: Vitest.Mock;
+    /** Get all key-value entries */
+    entries: Vitest.Mock;
+    /** Iterate over parameters */
+    forEach: Vitest.Mock;
+    /** Convert to string */
+    toString: Vitest.Mock;
+}
+/**
+ * Mock Next.js environment variables interface
+ *
+ * @example
+ * ```typescript
+ * const env: MockNextEnv = {
+ *   NEXT_PUBLIC_: {
+ *     'API_URL': 'http://localhost:3000',
+ *     'FEATURE_FLAG': 'true'
+ *   },
+ *   NODE_ENV: 'test'
+ * };
+ * ```
+ */
+export interface MockNextEnv {
+    /** Public environment variables (NEXT_PUBLIC_ prefix) */
+    NEXT_PUBLIC_: Record<string, string>;
+    /** Node environment */
+    NODE_ENV: 'development' | 'production' | 'test';
+}
+/**
+ * Mock Next.js Image component props using ImageProps type
+ *
+ * @example
+ * ```typescript
+ * const imageProps: MockNextImage = {
+ *   src: '/image.jpg',
+ *   alt: 'Test image',
+ *   width: 100,
+ *   height: 100
+ * };
+ *
+ * render(<MockImage {...imageProps} />);
+ * ```
+ */
+export type MockNextImage = NextImage.ImageProps;
+/**
+ * Options for creating HTTP mocks
+ *
+ * @example
+ * ```typescript
+ * const options: HttpMockOptions = {
+ *   framework: 'nextjs',
+ *   includeStreams: true
+ * };
+ *
+ * const httpMock = createHttpMock(options);
+ * ```
+ */
+export interface HttpMockOptions {
+    /** Target framework for mock compatibility */
+    framework?: 'node' | 'express' | 'nextjs';
+    /** Include stream functionality in mocks */
+    includeStreams?: boolean;
+}
+/**
+ * Mock HTTP request interface for testing HTTP handlers
+ *
+ * @example
+ * ```typescript
+ * const request: MockHttpRequest = {
+ *   method: 'POST',
+ *   url: '/api/users',
+ *   headers: { 'content-type': 'application/json' },
+ *   query: { page: '1' },
+ *   params: { id: '123' },
+ *   body: { name: 'John' },
+ *   cookies: { session: 'abc123' }
+ * };
+ * ```
+ */
+export interface MockHttpRequest {
+    /** HTTP method */
+    method: string;
+    /** Request URL */
+    url: string;
+    /** Request headers */
+    headers: Record<string, string | string[]>;
+    /** Query parameters */
+    query: Record<string, string | string[]>;
+    /** Route parameters */
+    params: Record<string, string>;
+    /** Request body */
+    body: unknown;
+    /** Request cookies */
+    cookies?: Record<string, string>;
+    /** Environment variables */
+    env?: Record<string, string | undefined>;
+    /** Socket information */
+    socket?: {
+        /** Remote IP address */
+        remoteAddress: string;
+        /** Remote port number */
+        remotePort: number;
+    };
+    /** Add event listener */
+    on?: Vitest.Mock;
+    /** Add one-time event listener */
+    once?: Vitest.Mock;
+    /** Emit event */
+    emit?: Vitest.Mock;
+    /** Pipe to stream */
+    pipe?: Vitest.Mock;
+    /** Unpipe from stream */
+    unpipe?: Vitest.Mock;
+    /** Pause stream */
+    pause?: Vitest.Mock;
+    /** Resume stream */
+    resume?: Vitest.Mock;
+}
+/**
+ * Mock HTTP response interface for testing HTTP handlers
+ *
+ * @example
+ * ```typescript
+ * const response: MockHttpResponse = createMockHttpResponse();
+ *
+ * // Mock response methods
+ * response.status.mockReturnThis();
+ * response.json.mockReturnThis();
+ *
+ * // Test response
+ * response.status(200).json({ success: true });
+ * expect(response.statusCode).toBe(200);
+ * ```
+ */
+export interface MockHttpResponse {
+    /** Current status code */
+    statusCode: number;
+    /** Current status message */
+    statusMessage: string;
+    /** Set status code */
+    status: Vitest.Mock;
+    /** Send JSON response */
+    json: Vitest.Mock;
+    /** Send response */
+    send: Vitest.Mock;
+    /** Set response header */
+    setHeader: Vitest.Mock;
+    /** Get response header */
+    getHeader: Vitest.Mock;
+    /** Remove response header */
+    removeHeader: Vitest.Mock;
+    /** Write to response */
+    write: Vitest.Mock;
+    /** End response */
+    end: Vitest.Mock;
+    /** Write response head */
+    writeHead?: Vitest.Mock;
+    /** Redirect response */
+    redirect?: Vitest.Mock;
+    /** Add event listener */
+    on?: Vitest.Mock;
+    /** Add one-time event listener */
+    once?: Vitest.Mock;
+    /** Emit event */
+    emit?: Vitest.Mock;
+    /** Whether response is finished */
+    finished?: boolean;
+    /** Whether headers are sent */
+    headersSent?: boolean;
+    /** Response headers */
+    headers?: Record<string, string | string[]>;
+}
+/**
+ * Browser history entry interface
+ *
+ * @example
+ * ```typescript
+ * const entry: HistoryEntry = {
+ *   pathname: '/users/123',
+ *   search: '?tab=profile',
+ *   hash: '#section',
+ *   state: { fromSearch: true }
+ * };
+ * ```
+ */
+export interface HistoryEntry {
+    /** URL pathname */
+    pathname: string;
+    /** URL search string */
+    search: string;
+    /** URL hash fragment */
+    hash: string;
+    /** History state data */
+    state: unknown;
+}
+/**
+ * HTTP request/response pair for testing HTTP interactions
+ *
+ * @example
+ * ```typescript
+ * const pair: HttpRequestResponsePair = {
+ *   req: createMockHttpRequest(),
+ *   res: createMockHttpResponse()
+ * };
+ *
+ * await handler(pair.req, pair.res);
+ * ```
+ */
+export interface HttpRequestResponsePair {
+    /** Mock HTTP request */
+    req: MockHttpRequest;
+    /** Mock HTTP response */
+    res: MockHttpResponse;
+}
+/**
+ * Middleware context for testing Express-style middleware
+ *
+ * @example
+ * ```typescript
+ * const context: MiddlewareContext = {
+ *   req: createMockHttpRequest(),
+ *   res: createMockHttpResponse(),
+ *   next: vi.fn()
+ * };
+ *
+ * await middleware(context.req, context.res, context.next);
+ * expect(context.next).toHaveBeenCalled();
+ * ```
+ */
+export interface MiddlewareContext {
+    /** Mock HTTP request */
+    req: MockHttpRequest;
+    /** Mock HTTP response */
+    res: MockHttpResponse;
+    /** Next function mock */
+    next: Vitest.Mock;
+}
+/**
+ * Options for stream piping operations
+ *
+ * @example
+ * ```typescript
+ * const options: PipeOptions = {
+ *   end: false // Don't end destination on source end
+ * };
+ *
+ * sourceStream.pipe(destinationStream, options);
+ * ```
+ */
+export interface PipeOptions {
+    /** Whether to end destination when source ends */
+    end?: boolean;
+}
+/**
+ * Next.js Link child component props
+ *
+ * @example
+ * ```typescript
+ * const childProps: NextLinkChildProps = {
+ *   children: <span>Click me</span>
+ * };
+ *
+ * const childrenArray: NextLinkChildProps = {
+ *   children: [<span key="1">Link</span>, <span key="2">Text</span>]
+ * };
+ * ```
+ */
+export interface NextLinkChildProps {
+    /** Child elements for Next.js Link */
+    children: React.ReactElement | React.ReactElement[];
+}
+/**
+ * Error handler mock interface for testing error handling
+ *
+ * @example
+ * ```typescript
+ * const errorHandler: ErrorHandlerMock = {
+ *   onError: vi.fn(),
+ *   onCatch: vi.fn(),
+ *   onFinally: vi.fn(),
+ *   reset: () => {
+ *     errorHandler.onError.mockClear();
+ *     errorHandler.onCatch.mockClear();
+ *     errorHandler.onFinally.mockClear();
+ *   }
+ * };
+ * ```
+ */
+export interface ErrorHandlerMock {
+    /** Error event handler */
+    onError: Vitest.Mock;
+    /** Catch block handler */
+    onCatch: Vitest.Mock;
+    /** Finally block handler */
+    onFinally: Vitest.Mock;
+    /** Reset all handlers */
+    reset: () => void;
+}
+/**
+ * Generic value wrapper interface
+ *
+ * @typeParam T - Type of the wrapped value
+ *
+ * @example
+ * ```typescript
+ * const wrapper: ValueWrapper<string> = {
+ *   value: 'wrapped string'
+ * };
+ *
+ * const numberWrapper: ValueWrapper<number> = {
+ *   value: 42
+ * };
+ * ```
+ */
+export interface ValueWrapper<T> {
+    /** The wrapped value */
+    value: T;
+}
+/**
+ * HTTP test scenario for testing different HTTP interactions
+ *
+ * @example
+ * ```typescript
+ * const scenario: HttpTestScenario = {
+ *   name: 'GET user by ID',
+ *   framework: 'nextjs',
+ *   request: {
+ *     method: 'GET',
+ *     url: '/api/users/123'
+ *   },
+ *   expectedStatus: 200,
+ *   expectedBody: { id: 123, name: 'John' },
+ *   expectedHeaders: { 'content-type': 'application/json' }
+ * };
+ * ```
+ */
+export interface HttpTestScenario {
+    /** Descriptive name for the test scenario */
+    name: string;
+    /** Target framework for the test */
+    framework?: 'node' | 'express' | 'nextjs';
+    /** Mock request configuration */
+    request?: Partial<MockHttpRequest>;
+    /** Expected HTTP status code */
+    expectedStatus: number;
+    /** Expected response body */
+    expectedBody?: unknown;
+    /** Expected response headers */
+    expectedHeaders?: Record<string, string | string[]>;
+    /** Expected redirect URL */
+    expectedRedirect?: string;
+}
+/**
+ * Timer callback entry for tracking scheduled callbacks
+ *
+ * @example
+ * ```typescript
+ * const entry: TimerCallbackEntry = {
+ *   callback: () => console.log('Timer fired'),
+ *   args: ['arg1', 'arg2']
+ * };
+ * ```
+ */
+export interface TimerCallbackEntry {
+    /** Function to be called */
+    callback: Function;
+    /** Arguments to pass to callback */
+    args: unknown[];
+}
+/**
+ * Mock HTTP server interface for testing server operations
+ *
+ * @example
+ * ```typescript
+ * const server: MockHttpServer = createMockHttpServer();
+ *
+ * // Mock server operations
+ * server.listen.mockImplementation((port, callback) => {
+ *   callback();
+ * });
+ *
+ * server.address.mockReturnValue({ port: 3000, family: 'IPv4' });
+ * ```
+ */
+export interface MockHttpServer {
+    /** Start listening on port */
+    listen: Vitest.Mock;
+    /** Close server */
+    close: Vitest.Mock;
+    /** Get server address */
+    address: Vitest.Mock;
+    /** Active connections */
+    connections: Set<unknown>;
+    /** Get connection count */
+    getConnections: Vitest.Mock;
+    /** Add event listener */
+    on: Vitest.Mock;
+    /** Add one-time event listener */
+    once: Vitest.Mock;
+    /** Emit server event */
+    emit: Vitest.Mock;
+}
+/**
+ * Mock readable stream interface extending EventEmitter
+ *
+ * @example
+ * ```typescript
+ * const stream: MockReadableStream = createMockReadableStream();
+ *
+ * // Mock stream operations
+ * stream.read.mockReturnValue(Buffer.from('data'));
+ * stream.readable = true;
+ *
+ * // Test stream piping
+ * stream.pipe(destinationStream);
+ * ```
+ */
+export interface MockReadableStream extends MockEventEmitter {
+    /** Read data from stream */
+    read: ReturnType<typeof Vitest.vi.fn>;
+    /** Pause stream */
+    pause: ReturnType<typeof Vitest.vi.fn>;
+    /** Resume stream */
+    resume: ReturnType<typeof Vitest.vi.fn>;
+    /** Pipe to another stream */
+    pipe: ReturnType<typeof Vitest.vi.fn>;
+    /** Unpipe from stream */
+    unpipe: ReturnType<typeof Vitest.vi.fn>;
+    /** Whether stream is readable */
+    readable: boolean;
+    /** Destroy stream */
+    destroy: ReturnType<typeof Vitest.vi.fn>;
+    /** Push data to stream */
+    push: ReturnType<typeof Vitest.vi.fn>;
+    /** Set character encoding */
+    setEncoding: ReturnType<typeof Vitest.vi.fn>;
+}
+/**
+ * Mock writable stream interface extending EventEmitter
+ *
+ * @example
+ * ```typescript
+ * const stream: MockWritableStream = createMockWritableStream();
+ *
+ * // Mock stream operations
+ * stream.write.mockReturnValue(true);
+ * stream.writable = true;
+ *
+ * // Test writing to stream
+ * stream.write('data');
+ * stream.end();
+ * ```
+ */
+export interface MockWritableStream extends MockEventEmitter {
+    /** Write data to stream */
+    write: ReturnType<typeof Vitest.vi.fn>;
+    /** End stream */
+    end: ReturnType<typeof Vitest.vi.fn>;
+    /** Whether stream is writable */
+    writable: boolean;
+    /** Destroy stream */
+    destroy: ReturnType<typeof Vitest.vi.fn>;
+    /** Cork stream (buffer writes) */
+    cork: ReturnType<typeof Vitest.vi.fn>;
+    /** Uncork stream (flush buffer) */
+    uncork: ReturnType<typeof Vitest.vi.fn>;
+}
+/**
+ * Mock duplex stream interface combining readable and writable streams
+ *
+ * @example
+ * ```typescript
+ * const stream: MockDuplexStream = createMockDuplexStream();
+ *
+ * // Can both read and write
+ * stream.write('input data');
+ * const output = stream.read();
+ * ```
+ */
+export interface MockDuplexStream extends MockReadableStream, MockWritableStream {
+}
+/**
+ * Mock stream instance containing different stream types
+ *
+ * @example
+ * ```typescript
+ * const streams: MockStreamInstance = createMockStreams();
+ *
+ * // Use different stream types
+ * streams.readable.pipe(streams.writable);
+ * streams.transform._transform(chunk, encoding, callback);
+ *
+ * // Get accumulated content
+ * const content = streams.writable.getContent();
+ * ```
+ */
+export interface MockStreamInstance {
+    /** Mock readable stream */
+    readable: MockReadableStream;
+    /** Mock writable stream with content tracking */
+    writable: MockWritableStream & {
+        /** Accumulated written chunks */
+        chunks: Array<string | globalThis.Buffer>;
+        /** Get all written content as buffer */
+        getContent: () => globalThis.Buffer;
+    };
+    /** Mock transform stream */
+    transform: MockTransformStream;
+}
+/**
+ * Mock transform stream interface extending duplex stream
+ *
+ * @example
+ * ```typescript
+ * const stream: MockTransformStream = createMockTransformStream();
+ *
+ * // Mock transform operations
+ * stream._transform.mockImplementation((chunk, encoding, callback) => {
+ *   const transformed = chunk.toString().toUpperCase();
+ *   callback(null, transformed);
+ * });
+ * ```
+ */
+export interface MockTransformStream extends MockDuplexStream {
+    /** Transform function implementation */
+    _transform: ReturnType<typeof Vitest.vi.fn>;
+    /** Flush function implementation */
+    _flush: ReturnType<typeof Vitest.vi.fn>;
+}
+/**
+ * NestJS module mock container with restoration capability
+ *
+ * @example
+ * ```typescript
+ * const moduleMock: NestJsModuleMock = createNestJsModuleMock();
+ *
+ * // Use mocks in test
+ * moduleMock.mocks.Injectable.mockReturnValue(() => {});
+ *
+ * // Restore after test
+ * moduleMock.restore();
+ * ```
+ */
+export interface NestJsModuleMock {
+    /** Collection of NestJS mocks */
+    mocks: NestJsCommonMocks;
+    /** Restore original implementations */
+    restore: () => void;
+}
+/**
+ * Return type for stateful counter mock
+ *
+ * @example
+ * ```typescript
+ * const counter: CreateStatefulCounterMockReturn = createStatefulCounterMock();
+ *
+ * counter.methods.increment();
+ * expect(counter.state.value).toBe(1);
+ * ```
+ */
+export type CreateStatefulCounterMockReturn = StatefulMock<{
+    value: number;
+}, Record<string, Vitest.Mock>>;
+/**
+ * Base interface for stateful mocks with state management
+ *
+ * @typeParam TState - Type of the mock's internal state
+ * @typeParam TMethods - Type of the mock's methods
+ *
+ * @example
+ * ```typescript
+ * interface UserState {
+ *   users: User[];
+ * }
+ *
+ * const mock: StatefulMock<UserState, { addUser: Mock }> = {
+ *   state: { users: [] },
+ *   methods: { addUser: vi.fn() },
+ *   setState: (newState) => { ... },
+ *   getState: () => ({ ...state }),
+ *   reset: () => { ... },
+ *   history: [],
+ *   clearHistory: () => { ... }
+ * };
+ * ```
+ */
+export interface StatefulMock<TState, TMethods> {
+    /** Current state of the mock */
+    state: TState;
+    /** Mock methods that can interact with state */
+    methods: TMethods;
+    /** Update the mock's state */
+    setState: (newState: Partial<TState>) => void;
+    /** Get a copy of current state */
+    getState: () => TState;
+    /** Reset state and methods to initial values */
+    reset: () => void;
+    /** History of method calls with arguments and timestamps */
+    history: Array<{
+        method: string;
+        args: unknown[];
+        timestamp: number;
+    }>;
+    /** Clear the call history */
+    clearHistory: () => void;
+}
+/**
+ * Options for creating a stateful mock
+ *
+ * @typeParam TState - Type of the mock's initial state
+ *
+ * @example
+ * ```typescript
+ * const options: StatefulMockOptions<{ count: number }> = {
+ *   initialState: { count: 0 },
+ *   trackHistory: true,
+ *   onStateChange: (newState, oldState) => {
+ *     console.log(`Count changed from ${oldState.count} to ${newState.count}`);
+ *   }
+ * };
+ *
+ * const mock = createStatefulMock(options);
+ * ```
+ */
+export interface StatefulMockOptions<TState> {
+    /** Initial state for the mock */
+    initialState: TState;
+    /** Whether to track method call history */
+    trackHistory?: boolean;
+    /** Callback fired when state changes */
+    onStateChange?: (newState: TState, oldState: TState) => void;
+}
+/**
+ * Type definition for createMockUseRouter function return
+ */
+export type CreateMockUseRouterReturn = Vitest.Mock;
+/**
+ * Type definition for createMockWebSocket function return
+ */
+export interface CreateMockWebSocketReturn {
+    url: string;
+    protocol: string;
+    extensions: string;
+    readyState: number;
+    bufferedAmount: number;
+    binaryType: 'blob' | 'arraybuffer';
+    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.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
+ */
+export type CreateMockNextRequestFunction = (url: string, options?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    searchParams?: Record<string, string>;
+}) => {
+    url: string;
+    method: string;
+    headers: Headers;
+    body: unknown;
+    ip: string;
+    searchParams?: Record<string, string>;
+    nextUrl: {
+        pathname: string;
+        searchParams: URLSearchParams;
+        origin: string;
+        href: string;
+    };
+    cookies: {
+        get: Vitest.Mock;
+        set: Vitest.Mock;
+        delete: Vitest.Mock;
+    };
+    geo: {
+        city: string;
+        country: string;
+        region: string;
+        latitude: string;
+        longitude: string;
+    };
+};
+/**
+ * Type definition for createMockWebSocketServer function return
+ */
+export interface CreateMockWebSocketServerReturn {
+    clients: Set<CreateMockWebSocketReturn>;
+    port: number;
+    host: string;
+    maxClients: number;
+    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.Mock;
+    off: Vitest.Mock;
+    emit: Vitest.Mock;
+    addListener: Vitest.Mock;
+    removeListener: Vitest.Mock;
+    removeAllListeners: Vitest.Mock;
+    listeners: Vitest.Mock;
+    listenerCount: Vitest.Mock;
+}