@plyaz/types 1.5.0 → 1.5.2

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

@@ -271,7 +271,7 @@ export interface RetryOptions {
  */
 export interface MockAsync<T = void> {
     /** The mock function that returns promises */
-    mock: Vitest.MockInstance;
+    mock: Vitest.Mock;
     /** Resolve the next pending promise with a value */
     resolve: (value: T) => void;
     /** Reject the next pending promise with an error */
@@ -555,19 +555,70 @@ export interface PollingTestOptions {
     /** Callback invoked after each poll */
     onPoll?: (attempt: number, result: unknown) => void;
 }
+/**
+ * Manages cleanup tasks during testing.
+ * Ensures proper resource disposal after tests.
+ *
+ * @example
+ * ```typescript
+ * const cleanup: TestCleanup = {
+ *   add: (fn) => cleanupTasks.push(fn),
+ *   runAll: async () => {
+ *     for (const task of cleanupTasks) {
+ *       await task();
+ *     }
+ *   },
+ *   clear: () => { cleanupTasks = []; }
+ * };
+ * ```
+ */
 export interface TestCleanup {
     add: (cleanup: () => void | Promise<void>) => void;
     runAll: () => Promise<void>;
     clear: () => void;
 }
+/**
+ * Mock console interface for capturing console output.
+ * Provides methods to intercept and restore console methods.
+ *
+ * @example
+ * ```typescript
+ * const mockConsole: MockConsole = {
+ *   log: vi.fn(),
+ *   error: vi.fn(),
+ *   warn: vi.fn(),
+ *   info: vi.fn(),
+ *   debug: vi.fn(),
+ *   restore: () => {
+ *     console.log = originalLog;
+ *     console.error = originalError;
+ *   }
+ * };
+ * ```
+ */
 export interface MockConsole {
-    log: Vitest.MockInstance;
-    error: Vitest.MockInstance;
-    warn: Vitest.MockInstance;
-    info: Vitest.MockInstance;
-    debug: Vitest.MockInstance;
+    log: Vitest.Mock;
+    error: Vitest.Mock;
+    warn: Vitest.Mock;
+    info: Vitest.Mock;
+    debug: Vitest.Mock;
     restore: () => void;
 }
+/**
+ * Mock environment variables for testing.
+ * Allows safe modification and restoration of process.env.
+ *
+ * @example
+ * ```typescript
+ * const mockEnv: MockEnv = {
+ *   set: (key, value) => { process.env[key] = value; },
+ *   get: (key) => process.env[key],
+ *   delete: (key) => { delete process.env[key]; },
+ *   clear: () => { // Clear all },
+ *   restore: () => { // Restore original }
+ * };
+ * ```
+ */
 export interface MockEnv {
     set: (key: string, value: string) => void;
     get: (key: string) => string | undefined;
@@ -575,6 +626,28 @@ export interface MockEnv {
     clear: () => void;
     restore: () => void;
 }
+/**
+ * Generic data cleanup manager for test data.
+ * Handles cleanup of created test resources.
+ *
+ * @template T - Type of data being cleaned up
+ *
+ * @example
+ * ```typescript
+ * const dataCleanup: TestDataCleanup<User> = {
+ *   addResource: (user) => resources.push(user),
+ *   cleanup: async (resource) => {
+ *     await userService.delete(resource.id);
+ *   },
+ *   cleanupAll: async () => {
+ *     for (const user of resources) {
+ *       await userService.delete(user.id);
+ *     }
+ *   },
+ *   reset: () => { resources = []; }
+ * };
+ * ```
+ */
 export interface TestDataCleanup<T> {
     register: (data: T) => T;
     cleanup: () => Promise<void>;
@@ -583,6 +656,22 @@ export interface TestDataCleanup<T> {
 export type RenderOptions = RTLRenderOptions;
 export type RenderHookOptions<TProps> = RTLRenderHookOptions<TProps>;
 export type SpyInstance = Vitest.MockedFunction<(...args: unknown[]) => unknown>;
+/**
+ * Options for performance benchmarking.
+ * Configures benchmark execution parameters.
+ *
+ * @example
+ * ```typescript
+ * const benchmarkOptions: BenchmarkOptions = {
+ *   iterations: 10000,
+ *   warmup: 100,
+ *   minTime: 1000, // Run for at least 1 second
+ *   maxTime: 5000, // Stop after 5 seconds
+ *   runs: 5,
+ *   format: 'table'
+ * };
+ * ```
+ */
 export interface BenchmarkOptions {
     iterations?: number;
     time?: number;
@@ -592,6 +681,19 @@ export interface BenchmarkOptions {
     runs?: number;
     format?: 'table' | 'json';
 }
+/**
+ * Configuration for test bed setup.
+ * Defines module dependencies and providers for testing.
+ *
+ * @example
+ * ```typescript
+ * const testBedConfig: TestBedConfig = {
+ *   providers: [UserService, AuthService],
+ *   imports: [HttpModule, ConfigModule],
+ *   exports: [UserService]
+ * };
+ * ```
+ */
 export interface TestBedConfig {
     providers: Provider[];
     imports?: unknown[];
@@ -610,6 +712,24 @@ export interface ValidateMiddlwareResponseExpected {
     url?: string;
     status?: number;
 }
+/**
+ * Options for creating service test harness.
+ * Configures mock providers and dependencies.
+ *
+ * @template T - Type of service being tested
+ *
+ * @example
+ * ```typescript
+ * const options: ServiceTestHarnessOptions<UserService> = {
+ *   mockProviders: [
+ *     { provide: DatabaseService, useValue: mockDb },
+ *     { provide: CacheService, useValue: mockCache }
+ *   ],
+ *   spyMethods: ['create', 'update', 'delete'],
+ *   mockLogger: true
+ * };
+ * ```
+ */
 export interface ServiceTestHarnessOptions<T> {
     Service: Type<T>;
     dependencies?: Array<{
@@ -633,6 +753,22 @@ export interface NextPageTestOptions extends RenderOptions {
 }
 export type NextApiRequest = NextJSApiRequest;
 export type NextApiResponse = NextJSApiResponse;
+/**
+ * Test context for API route handlers.
+ * Provides utilities for testing Next.js API routes.
+ *
+ * @example
+ * ```typescript
+ * const context: ApiRouteTestContext = {
+ *   req: createMockRequest({ method: 'POST', body: { name: 'Test' } }),
+ *   res: createMockResponse(),
+ *   expectStatus: (code) => expect(res.status).toHaveBeenCalledWith(code),
+ *   expectJson: (data) => expect(res.json).toHaveBeenCalledWith(data),
+ *   expectRedirect: (url) => expect(res.redirect).toHaveBeenCalledWith(url),
+ *   expectHeader: (name, value) => expect(res.setHeader).toHaveBeenCalledWith(name, value)
+ * };
+ * ```
+ */
 export interface ApiRouteTestContext {
     req: NextApiRequest;
     res: NextApiResponse;
@@ -641,6 +777,23 @@ export interface ApiRouteTestContext {
     expectRedirect: (url: string, status?: number) => void;
     expectHeader: (name: string, value: string | string[]) => void;
 }
+/**
+ * Test context for middleware functions.
+ * Provides utilities for testing Express/Next.js middleware.
+ *
+ * @example
+ * ```typescript
+ * const context: MiddlewareTestContext = {
+ *   req: createMockRequest(),
+ *   res: createMockResponse(),
+ *   next: vi.fn(),
+ *   expectStatus: (code) => expect(res.status).toHaveBeenCalledWith(code),
+ *   expectRedirect: (url) => expect(res.redirect).toHaveBeenCalledWith(url),
+ *   expectHeader: (name, value) => expect(res.setHeader).toHaveBeenCalledWith(name, value),
+ *   expectNext: () => expect(next).toHaveBeenCalled()
+ * };
+ * ```
+ */
 export interface MiddlewareTestContext {
     request: Request;
     event: {
@@ -666,6 +819,23 @@ export interface UserEventConfig {
     skipAutoClose?: boolean;
     writeToClipboard?: boolean;
 }
+/**
+ * Sequence of user interactions for testing.
+ * Defines ordered actions to simulate user behavior.
+ *
+ * @example
+ * ```typescript
+ * const sequence: InteractionSequence = {
+ *   steps: [
+ *     { type: 'click', target: '#login-btn' },
+ *     { type: 'type', target: '#username', text: 'testuser' },
+ *     { type: 'type', target: '#password', text: 'pass123' },
+ *     { type: 'press', key: 'Enter' },
+ *     { type: 'wait', duration: 1000 }
+ *   ]
+ * };
+ * ```
+ */
 export interface InteractionSequence {
     type: 'click' | 'type' | 'select' | 'check' | 'focus' | 'blur' | 'hover' | 'key' | 'paste' | 'clear' | 'upload' | 'drag' | 'scroll' | 'wait' | 'tab' | 'keyboard';
     target?: string | HTMLElement;
@@ -807,6 +977,24 @@ export interface WaitForChangeOptions<T> {
     interval?: number;
     compareFn?: (a: T, b: T) => boolean;
 }
+/**
+ * Performance metrics from test runs.
+ * Contains statistical data about execution performance.
+ *
+ * @example
+ * ```typescript
+ * const metrics: PerformanceMetrics = {
+ *   mean: 25.5,
+ *   median: 24,
+ *   stdDev: 3.2,
+ *   min: 18,
+ *   max: 45,
+ *   p95: 35,
+ *   p99: 42,
+ *   runs: [22, 24, 18, 25, 28, 45, 23, 24, 26, 21]
+ * };
+ * ```
+ */
 export interface PerformanceMetrics {
     min: number;
     max: number;
@@ -841,6 +1029,23 @@ export interface LoadTestStats {
     latencies: number[];
     errors: Error[];
 }
+/**
+ * Results from load testing operations.
+ * Contains throughput and performance data under load.
+ *
+ * @example
+ * ```typescript
+ * const loadTestResult: LoadTestResult = {
+ *   totalRequests: 10000,
+ *   successfulRequests: 9950,
+ *   failedRequests: 50,
+ *   averageLatency: 125,
+ *   p95Latency: 250,
+ *   throughput: 400, // requests per second
+ *   errors: [new Error('Connection timeout')]
+ * };
+ * ```
+ */
 export interface LoadTestResult {
     totalRequests: number;
     successfulRequests: number;
@@ -881,6 +1086,20 @@ export interface PerformanceComparisonInput<T> {
     name: string;
     value: T;
 }
+/**
+ * Memory measurement data from profiling.
+ * Tracks memory usage before, after, and peak consumption.
+ *
+ * @example
+ * ```typescript
+ * const measurement: MemoryMeasurement = {
+ *   before: 50 * 1024 * 1024, // 50MB
+ *   after: 55 * 1024 * 1024,  // 55MB
+ *   delta: 5 * 1024 * 1024,   // 5MB increase
+ *   peak: 60 * 1024 * 1024    // 60MB peak
+ * };
+ * ```
+ */
 export interface MemoryMeasurement {
     before: number;
     after: number;
@@ -926,6 +1145,22 @@ export interface WebSocketServerMockOptions {
     host?: string;
     maxClients?: number;
 }
+/**
+ * Test scenario for WebSocket connections.
+ * Defines connection behavior and message expectations.
+ *
+ * @example
+ * ```typescript
+ * const scenario: WebSocketTestScenario = {
+ *   url: 'ws://localhost:8080',
+ *   messages: ['ping', { type: 'subscribe', channel: 'updates' }],
+ *   expectedMessages: ['pong', { type: 'data', payload: {} }],
+ *   timeout: 5000,
+ *   shouldReconnect: true,
+ *   shouldError: false
+ * };
+ * ```
+ */
 export interface WebSocketTestScenario {
     name: string;
     message: unknown;
@@ -940,6 +1175,25 @@ export interface WebSocketConnectionOptions {
     headers?: Record<string, string>;
     timeout?: number;
 }
+/**
+ * Test configuration for file operations.
+ * Defines expected file system state after operations.
+ *
+ * @example
+ * ```typescript
+ * const fileTest: FileOperationTest = {
+ *   operation: async () => {
+ *     await fs.writeFile('test.txt', 'content');
+ *     await fs.rename('test.txt', 'renamed.txt');
+ *   },
+ *   expectedFiles: new Map([
+ *     ['renamed.txt', 'content'],
+ *     ['log.txt', Buffer.from('log data')]
+ *   ]),
+ *   expectedError: undefined
+ * };
+ * ```
+ */
 export interface FileOperationTest {
     name: string;
     operation: (fs: unknown) => void | Promise<void>;
@@ -950,6 +1204,24 @@ export interface SignalTest {
     signal: string;
     expectedBehavior: () => void;
 }
+/**
+ * ARIA attributes for accessibility testing.
+ * Defines accessibility properties for elements.
+ *
+ * @example
+ * ```typescript
+ * const ariaAttrs: AriaAttributes = {
+ *   'aria-label': 'Submit form',
+ *   'aria-describedby': 'form-help',
+ *   'aria-required': 'true',
+ *   'aria-invalid': 'false',
+ *   'aria-expanded': 'false',
+ *   'aria-hidden': 'false',
+ *   role: 'button',
+ *   tabIndex: 0
+ * };
+ * ```
+ */
 export interface AriaAttributes {
     ariaLabel?: string;
     ariaLabelledby?: string;
@@ -987,6 +1259,26 @@ export interface LifecycleHook {
     required?: boolean;
     async?: boolean;
 }
+/**
+ * Test configuration for component lifecycle.
+ * Defines expected lifecycle hook sequences.
+ *
+ * @example
+ * ```typescript
+ * const lifecycleTest: ComponentLifecycleTest = {
+ *   component: UserProfile,
+ *   props: { userId: '123' },
+ *   expectedLifecycle: ['constructor', 'componentDidMount', 'render'],
+ *   actions: [
+ *     {
+ *       type: 'update',
+ *       props: { userId: '456' },
+ *       expectedHooksAfter: ['componentDidUpdate', 'render']
+ *     }
+ *   ]
+ * };
+ * ```
+ */
 export interface ComponentLifecycleTest {
     name: string;
     Component: React.ComponentType<unknown>;
@@ -1033,6 +1325,24 @@ export interface ApplicationLifecycleTest {
     expectedStartupSequence: string[];
     expectedShutdownSequence: string[];
 }
+/**
+ * Configuration for test suite setup.
+ * Defines shared setup and teardown for test groups.
+ *
+ * @template T - Type of test context data
+ *
+ * @example
+ * ```typescript
+ * const config: TestSuiteConfig<TestContext> = {
+ *   name: 'UserService Tests',
+ *   context: () => ({ db: null, service: null }),
+ *   setupBeforeAll: async () => { await db.connect(); },
+ *   setupBeforeEach: async () => { await db.clear(); },
+ *   teardownAfterEach: async () => { await db.rollback(); },
+ *   teardownAfterAll: async () => { await db.disconnect(); }
+ * };
+ * ```
+ */
 export interface TestSuiteConfig<T> {
     name: string;
     createInstance: () => T;
@@ -1063,6 +1373,23 @@ export interface KeyframeTest {
     percentage: number;
     styles: Record<string, string>;
 }
+/**
+ * Sequence of animation steps for testing.
+ * Defines keyframes and timing for animations.
+ *
+ * @example
+ * ```typescript
+ * const sequence: AnimationSequence = {
+ *   name: 'slideIn',
+ *   duration: 500,
+ *   iterations: 1,
+ *   steps: [
+ *     { time: 0, styles: { opacity: 0, transform: 'translateX(-100%)' } },
+ *     { time: 500, styles: { opacity: 1, transform: 'translateX(0)' }, easing: 'ease-out' }
+ *   ]
+ * };
+ * ```
+ */
 export interface AnimationSequence {
     name: string;
     steps: Array<{
@@ -1149,10 +1476,10 @@ export interface MockCallResult {
     error?: unknown;
 }
 export interface FileWatcher extends MockEventEmitter {
-    add: Vitest.MockInstance;
-    unwatch: Vitest.MockInstance;
-    close: Vitest.MockInstance;
-    getWatched: Vitest.MockInstance;
+    add: Vitest.Mock;
+    unwatch: Vitest.Mock;
+    close: Vitest.Mock;
+    getWatched: Vitest.Mock;
     simulateChange: (path: string) => void;
     simulateAdd: (path: string) => void;
     simulateUnlink: (path: string) => void;
@@ -1197,9 +1524,9 @@ export interface MockNextRequest {
         href: string;
     };
     cookies: {
-        get: Vitest.MockInstance;
-        set: Vitest.MockInstance;
-        delete: Vitest.MockInstance;
+        get: Vitest.Mock;
+        set: Vitest.Mock;
+        delete: Vitest.Mock;
     };
     geo: {
         city: string;
@@ -1211,24 +1538,24 @@ export interface MockNextRequest {
 }
 export interface MockNextResponse {
     cookies: {
-        set: Vitest.MockInstance;
-        delete: Vitest.MockInstance;
+        set: Vitest.Mock;
+        delete: Vitest.Mock;
     };
     headers: Headers;
     status: number;
-    redirect: Vitest.MockInstance;
-    rewrite: Vitest.MockInstance;
-    next: Vitest.MockInstance;
-    json: Vitest.MockInstance;
+    redirect: Vitest.Mock;
+    rewrite: Vitest.Mock;
+    next: Vitest.Mock;
+    json: Vitest.Mock;
 }
 export interface MockWebSocketServer extends MockEventEmitter {
     clients: Set<CreateMockWebSocketReturn>;
     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;
@@ -1409,6 +1736,25 @@ export type LoadingResult = {
         current: LoadingState;
     };
 };
+/**
+ * Table-driven test case definition.
+ * Defines input and expected output for parameterized tests.
+ *
+ * @template TInput - Type of test input
+ * @template TExpected - Type of expected output
+ *
+ * @example
+ * ```typescript
+ * const testCase: TableTestCase<number, string> = {
+ *   name: 'converts positive number',
+ *   input: 42,
+ *   expected: 'forty-two',
+ *   only: false,
+ *   skip: false,
+ *   error: false
+ * };
+ * ```
+ */
 export interface TableTestCase<TInput, TExpected> {
     name: string;
     input: TInput;
@@ -1961,40 +2307,35 @@ export interface ProviderInjection {
     testFn: (instance: unknown, deps: unknown[]) => void;
 }
 export interface CreateMockRedisClientMock {
-    set: Vitest.MockInstance;
-    get: Vitest.MockInstance;
-    del: Vitest.MockInstance;
-    keys: Vitest.MockInstance;
-    quit: Vitest.MockInstance;
-    on: Vitest.MockInstance;
-    multi: Vitest.MockInstance;
-    ping: Vitest.MockInstance;
+    set: Vitest.Mock;
+    get: Vitest.Mock;
+    del: Vitest.Mock;
+    keys: Vitest.Mock;
+    quit: Vitest.Mock;
+    on: Vitest.Mock;
+    multi: Vitest.Mock;
+    ping: Vitest.Mock;
 }
 /**
  * Call tracker interface
  * @interface CallTracker
  */
 export interface CallTracker {
-    /** Track function call */
     trackCall: (name: string, args: unknown[]) => void;
-    /** Get calls */
     getCalls: (name?: string) => Array<{
         name: string;
         args: unknown[];
         timestamp: number;
     }>;
-    /** Reset tracker */
     reset: () => void;
 }
 /**
  * Tracked spy with additional properties
  * @interface TrackedSpy
- * @extends SpyInstance from @plyaz/types/testing
+ * @extends SpyInstance
  */
 export interface TrackedSpy extends SpyInstance {
-    /** Get call count */
     getCallCount: () => number;
-    /** Get call history */
     getCallHistory: () => Array<{
         args: unknown[];
         result?: unknown;
@@ -2014,9 +2355,7 @@ export type SpyMap<T> = {
  * @typeParam T - Type of tracked data
  */
 export interface TrackedData<T> {
-    /** Data being tracked */
     data: T;
-    /** Access history */
     accesses: Array<{
         property: string | symbol;
         timestamp: number;
@@ -2027,11 +2366,8 @@ export interface TrackedData<T> {
  * @interface AccessInfo
  */
 export interface AccessInfo {
-    /** Property being accessed */
     property: string | symbol;
-    /** Access timestamp */
     timestamp: number;
-    /** Access count */
     count: number;
 }
 /**
@@ -2039,29 +2375,21 @@ export interface AccessInfo {
  * @interface WorkerLike
  */
 export interface WorkerLike {
-    /** Error handler */
     onError?: (error: Error) => void;
-    /** Error event handler */
     onerror?: (error: Error | ErrorEvent) => void;
-    /** Event emitter */
     emit?: (event: string, data: unknown) => void;
-    /** Post message */
     postMessage?: (message: unknown) => void;
-    /** Event listener */
     on?: {
         (event: 'message', handler: (data: unknown) => void): void;
         (event: 'error', handler: (error: unknown) => void): void;
         (event: string, handler: (data: unknown) => void): void;
     };
-    /** Add event listener */
     addEventListener?: {
         (event: 'message', handler: (event: MessageEvent) => void): void;
         (event: 'error', handler: (event: ErrorEvent) => void): void;
         (event: string, handler: (event: Event) => void): void;
     };
-    /** Message handler */
     onmessage?: (event: MessageEvent) => void;
-    /** Terminate worker */
     terminate?: () => void;
 }
 /**
@@ -2069,15 +2397,10 @@ export interface WorkerLike {
  * @interface WorkerPool
  */
 export interface WorkerPool {
-    /** Add task to pool */
     addTask: (task: () => Promise<void>) => void;
-    /** Start pool */
     start: () => Promise<void>;
-    /** Stop pool */
     stop: () => void;
-    /** Wait for completion */
     waitForCompletion: () => Promise<void>;
-    /** Get pool statistics */
     getStats: () => {
         totalWorkers: number;
         busyWorkers: number;
@@ -2097,21 +2420,13 @@ export interface WorkerPool {
  * @interface WorkerMetrics
  */
 export interface WorkerMetrics {
-    /** Worker ID */
     workerId: number;
-    /** Task count */
     taskCount: number;
-    /** Execution time */
     executionTime: number;
-    /** Errors encountered */
     errors: Error[];
-    /** Throughput */
     throughput: number;
-    /** Average task time */
     avgTaskTime?: number;
-    /** Memory usage */
     memoryUsage?: number;
-    /** CPU usage */
     cpuUsage?: number;
 }
 /**
@@ -2119,21 +2434,18 @@ export interface WorkerMetrics {
  * @interface WorkerTestHarness
  */
 export interface WorkerTestHarness {
-    /** Run test scenario */
     run: () => Promise<{
         metrics: WorkerMetrics[];
         totalExecutionTime: number;
         totalTasks: number;
         totalErrors: number;
     }>;
-    /** Assert test results */
     assertResults: (results: {
         metrics: WorkerMetrics[];
         totalExecutionTime: number;
         totalTasks: number;
         totalErrors: number;
     }) => void;
-    /** Get aggregated metrics */
     getMetrics: () => {
         workerCount: number;
         totalTasks: number;
@@ -2148,19 +2460,12 @@ export interface WorkerTestHarness {
  * @interface WorkerSpy
  */
 export interface WorkerSpy {
-    /** Get messages sent */
     getMessagesSent: () => unknown[];
-    /** Get messages received */
     getMessagesReceived: () => unknown[];
-    /** Get errors */
     getErrors: () => Error[];
-    /** Check if terminated */
     isTerminated: () => boolean;
-    /** Simulate message */
     simulateMessage: (message: unknown) => void;
-    /** Simulate error */
     simulateError: (error: Error) => void;
-    /** Reset spy */
     reset: () => void;
 }
 /**
@@ -2189,6 +2494,7 @@ export interface ProfileResult<T> {
         samples: number[];
         /** Sample timestamps */
         timestamps: number[];
+        duration: number;
     };
     /** Memory profile data */
     memoryProfile?: {
@@ -2209,8 +2515,8 @@ export interface StressTestOptions {
     concurrency?: number;
     /** Ramp-up time */
     rampUp?: number;
-    /** Operation rate limit */
-    rate?: number;
+    maxErrors?: number;
+    errorThreshold?: number;
 }
 /**
  * Stress test result
@@ -2225,7 +2531,8 @@ export interface StressTestResult {
     failedOperations: number;
     /** Average response time */
     averageResponseTime: number;
-    /** Error details */
+    operationsPerSecond: number;
+    errorRate: number;
     errors: Error[];
 }
 /**
@@ -2239,8 +2546,9 @@ export interface ThroughputResult {
     duration: number;
     /** Throughput rate */
     throughput: number;
-    /** Peak throughput */
-    peakThroughput: number;
+    averageLatency: number;
+    minLatency: number;
+    maxLatency: number;
 }
 /**
  * Performance monitoring options
@@ -2264,11 +2572,11 @@ export interface PerformanceMonitor {
     /** Get collected metrics */
     getMetrics: () => {
         /** CPU metrics */
-        cpu: number[];
+        cpu?: number[];
         /** Memory metrics */
-        memory: number[];
+        memory?: number[];
         /** Time metrics */
-        time: number[];
+        timestamps: number[];
     };
 }
 /**
@@ -2298,8 +2606,6 @@ export interface LeakResult {
         iteration: number;
         /** Memory usage */
         memory: number;
-        /** Timestamp */
-        timestamp: number;
     }>;
 }
 /**
@@ -2307,103 +2613,65 @@ export interface LeakResult {
  * @interface HookScenario
  * @typeParam T - Type of hook result
  */
-export interface HookScenario<T> {
-    /** Scenario name */
+export interface HookScenario {
     name: string;
-    /** Initial props */
-    initialProps?: Record<string, unknown>;
-    /** Hook function to test */
-    hook: () => T;
-    /** Expected result */
-    expected: T;
-    /** Setup function */
-    setup?: () => void;
-    /** Cleanup function */
-    cleanup?: () => void;
+    action: () => void | Promise<void>;
+    expectedState: Record<string, unknown>;
+    expectedError?: Error | null;
 }
 /**
  * Context update configuration
  * @interface ContextUpdate
  * @typeParam T - Type of context value
  */
-export interface ContextUpdate<T> {
-    /** New context value */
-    value: T;
-    /** Update delay */
-    delay?: number;
-    /** Callback after update */
-    callback?: (value: T) => void;
+export interface ContextUpdate {
+    value: unknown;
+    expectedConsumerValue: unknown;
+    description?: string;
 }
 /**
  * Suspense testing options
  * @interface SuspenseOptions
  */
 export interface SuspenseOptions {
-    /** Fallback component */
     fallback?: React.ReactNode;
-    /** Timeout for suspense */
     timeout?: number;
-    /** Error boundary */
-    errorBoundary?: boolean;
 }
 /**
  * Concurrent rendering scenario
  * @interface ConcurrentScenario
  */
 export interface ConcurrentScenario {
-    /** Scenario name */
     name: string;
-    /** Component to render */
-    component: React.ReactNode;
-    /** Props updates */
-    updates: Array<{
-        /** Props to update */
-        props: Record<string, unknown>;
-        /** Update delay */
-        delay: number;
-    }>;
-    /** Expected renders count */
-    expectedRenders: number;
+    priority: 'high' | 'low' | 'normal';
+    action: () => void | Promise<void>;
+    expectedBehavior: () => void;
 }
 /**
  * Accessibility testing options
  * @interface A11yOptions
  */
 export interface A11yOptions {
-    /** ARIA rules to check */
-    rules?: string[];
-    /** Elements to include */
-    include?: string[];
-    /** Elements to exclude */
-    exclude?: string[];
-    /** Severity levels */
-    level?: 'AA' | 'AAA';
-    /** Tags to test */
-    tags?: string[];
+    runOnly?: string[];
+    rules?: Record<string, {
+        enabled: boolean;
+    }>;
+    resultTypes?: Array<'violations' | 'passes' | 'incomplete' | 'inapplicable'>;
 }
 /**
  * Accessibility violation
  * @interface A11yViolation
  */
 export interface A11yViolation {
-    /** Rule ID */
     id: string;
-    /** Violation description */
+    impact?: 'minor' | 'moderate' | 'serious' | 'critical';
     description: string;
-    /** Help text */
     help: string;
-    /** Help URL */
     helpUrl: string;
-    /** Impact level */
-    impact: 'minor' | 'moderate' | 'serious' | 'critical';
-    /** Affected nodes */
     nodes: Array<{
-        /** Element HTML */
-        html: string;
-        /** Element selector */
         target: string[];
-        /** Failure summary */
-        failureSummary: string;
+        html: string;
+        failureSummary?: string;
     }>;
 }
 /**
@@ -2411,16 +2679,13 @@ export interface A11yViolation {
  * @interface A11yPass
  */
 export interface A11yPass {
-    /** Rule ID */
     id: string;
-    /** Rule description */
     description: string;
-    /** Passed nodes */
+    help: string;
+    helpUrl: string;
     nodes: Array<{
-        /** Element HTML */
-        html: string;
-        /** Element selector */
         target: string[];
+        html: string;
     }>;
 }
 /**
@@ -2428,16 +2693,14 @@ export interface A11yPass {
  * @interface A11yIncomplete
  */
 export interface A11yIncomplete {
-    /** Rule ID */
     id: string;
-    /** Rule description */
     description: string;
-    /** Incomplete nodes */
+    help: string;
+    helpUrl: string;
     nodes: Array<{
-        /** Element HTML */
-        html: string;
-        /** Element selector */
         target: string[];
+        html: string;
+        message?: string;
     }>;
 }
 /**
@@ -2445,146 +2708,139 @@ export interface A11yIncomplete {
  * @interface A11yReport
  */
 export interface A11yReport {
-    /** Violations found */
     violations: A11yViolation[];
-    /** Tests that passed */
     passes: A11yPass[];
-    /** Incomplete tests */
     incomplete: A11yIncomplete[];
-    /** Test URL */
-    url: string;
-    /** Timestamp */
-    timestamp: Date;
+    inapplicable: Array<{
+        id: string;
+        description: string;
+    }>;
 }
 /**
  * Keyboard sequence for testing
  * @interface KeySequence
  */
 export interface KeySequence {
-    /** Keys to press */
-    keys: string[];
-    /** Delay between keys */
-    delay?: number;
-    /** Modifier keys */
-    modifiers?: Array<'shift' | 'ctrl' | 'alt' | 'meta'>;
+    key: string;
+    modifiers?: string[];
 }
 /**
  * Color contrast test result
  * @interface ContrastResult
  */
 export interface ContrastResult {
-    /** Foreground color */
-    foreground: string;
-    /** Background color */
-    background: string;
-    /** Contrast ratio */
+    passes: boolean;
     ratio: number;
-    /** WCAG AA compliance */
-    AA: boolean;
-    /** WCAG AAA compliance */
-    AAA: boolean;
+    standard: 'AA' | 'AAA';
+    largeText: boolean;
+    recommendation?: string;
 }
 /**
  * User session options
  * @interface SessionOptions
  */
 export interface SessionOptions {
-    /** Pointer events API */
-    pointerEventsCheck?: number;
-    /** Advanced timer */
-    advanceTimers?: () => void;
-    /** Skip hover */
-    skipHover?: boolean;
-    /** Skip click */
-    skipClick?: boolean;
-    /** Auto cleanup */
-    autoCleanup?: boolean;
+    userId?: string;
+    deviceType?: 'desktop' | 'mobile' | 'tablet';
+    browser?: string;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    locale?: string;
+    timezone?: string;
 }
 /**
  * User event session
  * @interface UserSession
  */
 export interface UserSession {
-    /** Click element */
-    click: (element: Element, options?: ClickOptions) => Promise<void>;
-    /** Double click element */
-    dblClick: (element: Element, options?: ClickOptions) => Promise<void>;
-    /** Type into element */
-    type: (element: Element, text: string, options?: TypeOptions) => Promise<void>;
-    /** Clear input */
-    clear: (element: Element) => Promise<void>;
-    /** Tab navigation */
-    tab: (options?: {
-        shift?: boolean;
-    }) => Promise<void>;
-    /** Hover element */
-    hover: (element: Element) => Promise<void>;
-    /** Unhover element */
-    unhover: (element: Element) => Promise<void>;
+    id: string;
+    userId: string;
+    deviceType: 'desktop' | 'mobile' | 'tablet';
+    browser: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    locale: string;
+    timezone: string;
+    startTime: Date;
+    interactions: Interaction[];
+    endSession: () => void;
 }
 /**
  * Click options
  * @interface ClickOptions
  */
 export interface ClickOptions {
-    /** Button to click */
-    button?: 'left' | 'middle' | 'right';
-    /** Click count */
-    clickCount?: number;
-    /** Skip hover */
-    skipHover?: boolean;
-    /** Click delay */
     delay?: number;
+    moveSpeed?: number;
+    pressure?: number;
+    jitter?: boolean;
 }
 /**
  * Type options
  * @interface TypeOptions
  */
 export interface TypeOptions {
-    /** Typing delay */
     delay?: number;
-    /** Skip click */
-    skipClick?: boolean;
-    /** Skip auto close */
-    skipAutoClose?: boolean;
-    /** Initial selection */
-    initialSelectionStart?: number;
-    /** Initial selection end */
-    initialSelectionEnd?: number;
+    typos?: boolean;
+    corrections?: boolean;
+    variableSpeed?: boolean;
 }
 /**
  * Drag options
  * @interface DragOptions
  */
 export interface DragOptions {
-    /** Delta coordinates */
-    delta?: {
-        x: number;
-        y: number;
-    };
-    /** Target element */
-    target?: Element;
-    /** Data transfer */
-    dataTransfer?: {
-        /** Transfer data */
-        getData: (format: string) => string;
-        /** Set transfer data */
-        setData: (format: string, data: string) => void;
-    };
+    duration?: number;
+    steps?: number;
+    dropEffect?: 'move' | 'copy' | 'link' | 'none';
 }
+export type TouchGestureAdvancedAdvanced = {
+    type: 'tap';
+    x: number;
+    y: number;
+} | {
+    type: 'doubleTap';
+    x: number;
+    y: number;
+} | {
+    type: 'longPress';
+    x: number;
+    y: number;
+    duration: number;
+} | {
+    type: 'swipe';
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+    duration: number;
+} | {
+    type: 'pinch';
+    centerX: number;
+    centerY: number;
+    startDistance: number;
+    endDistance: number;
+} | {
+    type: 'rotate';
+    centerX: number;
+    centerY: number;
+    startAngle: number;
+    endAngle: number;
+};
 /**
  * User interaction record
  * @interface Interaction
  */
 export interface Interaction {
-    /** Interaction type */
-    type: 'click' | 'type' | 'hover' | 'focus' | 'blur';
-    /** Target element */
-    element: Element;
-    /** Interaction data */
+    timestamp: Date;
+    type: string;
+    target: string;
     data?: unknown;
-    /** Timestamp */
-    timestamp: number;
+    duration?: number;
 }
 /**
  * Swipe gesture parameters
@@ -2628,70 +2884,44 @@ export interface PinchGestureParams {
  * @interface Frame
  */
 export interface Frame {
-    /** Frame timestamp */
     timestamp: number;
-    /** Frame progress */
-    progress: number;
-    /** Frame values */
-    values: Record<string, number>;
+    styles: Record<string, string>;
 }
 /**
  * Animation performance metrics
  * @interface AnimationMetrics
  */
 export interface AnimationMetrics {
-    /** Total duration */
     duration: number;
-    /** Frame count */
     frameCount: number;
-    /** Dropped frames */
-    droppedFrames: number;
-    /** Average FPS */
     averageFPS: number;
-    /** Minimum FPS */
-    minFPS: number;
-    /** Maximum FPS */
-    maxFPS: number;
+    paintTime: number;
+    layoutTime: number;
 }
 /**
  * RequestAnimationFrame options
  * @interface RAFOptions
  */
 export interface RAFOptions {
-    /** Auto start */
-    autoStart?: boolean;
-    /** Frame limit */
-    frameLimit?: number;
-    /** FPS target */
-    targetFPS?: number;
+    autoAdvance?: boolean;
+    frameTime?: number;
 }
 /**
  * RequestAnimationFrame mock
  * @interface RAFMock
  */
 export interface RAFMock {
-    /** Start animation */
-    start: () => void;
-    /** Stop animation */
-    stop: () => void;
-    /** Step to next frame */
-    step: () => void;
-    /** Get current time */
-    now: () => number;
-    /** Set frame rate */
-    setFrameRate: (fps: number) => void;
+    tick: (time?: number) => void;
+    reset: () => void;
+    getCallCount: () => number;
 }
 /**
  * Interval handle
  * @interface IntervalHandle
  */
 export interface IntervalHandle {
-    /** Interval ID */
-    id: number;
-    /** Clear interval */
-    clear: () => void;
-    /** Check if active */
-    isActive: () => boolean;
+    stop: () => void;
+    isRunning: () => boolean;
 }
 /**
  * Schedule handle
@@ -2710,36 +2940,26 @@ export interface ScheduleHandle {
  * @interface Timer
  */
 export interface Timer {
-    /** Start time */
-    startTime: number;
-    /** End time */
-    endTime?: number;
-    /** Elapsed time */
-    elapsed: number;
-    /** Timer label */
-    label?: string;
+    start: () => void;
+    stop: () => number;
+    pause: () => void;
+    resume: () => void;
+    getElapsed: () => number;
+    reset: () => void;
 }
-/**
- * Countdown timer
- * @interface Countdown
- */
 export interface Countdown {
-    /** Remaining time */
-    remaining: number;
-    /** Total duration */
-    duration: number;
-    /** Is running */
-    isRunning: boolean;
-    /** Is complete */
-    isComplete: boolean;
-    /** Completion callback */
-    onComplete?: () => void;
+    start: () => void;
+    pause: () => void;
+    resume: () => void;
+    getRemaining: () => number;
+    onComplete: (callback: () => void) => void;
+    cancel: () => void;
 }
 /**
  * History entry
  * @interface HistoryEntry
  */
-export interface HistoryEntry {
+export interface MockHistoryEntry {
     /** Entry URL */
     url: string;
     /** Entry state */
@@ -2754,20 +2974,19 @@ export interface HistoryEntry {
  * @interface MockHistory
  */
 export interface MockHistory {
-    /** History entries */
-    entries: HistoryEntry[];
-    /** Current index */
+    entries: MockHistoryEntry[];
     index: number;
-    /** Push entry */
-    push: (url: string, state?: unknown) => void;
-    /** Replace entry */
-    replace: (url: string, state?: unknown) => void;
-    /** Go back */
-    back: () => void;
-    /** Go forward */
-    forward: () => void;
-    /** Go to index */
-    go: (delta: number) => void;
+    push: (path: string, state?: unknown) => void;
+    replace: (path: string, state?: unknown) => void;
+    go: (n: number) => void;
+    goBack: () => void;
+    goForward: () => void;
+    canGo: (n: number) => boolean;
+    block: (blocker: (location: MockHistoryEntry, action: string) => string | false) => () => void;
+    listen: (listener: (location: MockHistoryEntry, action: string) => void) => () => void;
+    createHref: (location: Partial<MockHistoryEntry>) => string;
+    location: MockHistoryEntry;
+    length: number;
 }
 /**
  * Mock location object
@@ -2781,51 +3000,44 @@ export interface MockLocation {
     /** Current hash */
     hash: string;
     /** Current state */
-    state?: unknown;
+    state: unknown;
     /** Location key */
     key: string;
+    href: string;
+    origin: string;
+    protocol: string;
+    host: string;
+    hostname: string;
+    port: string;
 }
 /**
  * Route expectation
  * @interface RouteExpectation
  */
 export interface RouteExpectation {
-    /** Expected path */
-    path: string;
-    /** Expected params */
-    params?: Record<string, string>;
-    /** Expected query */
-    query?: Record<string, string>;
-    /** Should match exactly */
-    exact?: boolean;
+    params?: Record<string, string | string[]>;
+    query?: Record<string, string | string[]>;
+    beforeTransition?: () => void | Promise<void>;
+    afterTransition?: () => void | Promise<void>;
 }
 /**
  * Route guard configuration
  * @interface RouteGuard
  */
 export interface RouteGuard {
-    /** Guard name */
-    name: string;
-    /** Guard function */
-    guard: (route: string) => boolean | Promise<boolean>;
-    /** Redirect path */
-    redirectTo?: string;
-    /** Guard priority */
-    priority?: number;
+    canActivate?: (to: string, from: string) => boolean | Promise<boolean>;
+    canDeactivate?: (from: string, to: string) => boolean | Promise<boolean>;
 }
 /**
  * Guard scenario for testing
  * @interface GuardScenario
  */
 export interface GuardScenario {
-    /** Scenario name */
     name: string;
-    /** Route to test */
-    route: string;
-    /** Expected guard result */
-    expectedResult: boolean;
-    /** Expected redirect */
-    expectedRedirect?: string;
+    from: string;
+    to: string;
+    shouldAllow: boolean;
+    guardType: 'canActivate' | 'canDeactivate';
 }
 /**
  * Navigation options
@@ -2836,21 +3048,16 @@ export interface NavOptions {
     replace?: boolean;
     /** Navigation state */
     state?: unknown;
-    /** Prevent default */
-    preventDefault?: boolean;
+    shallow?: boolean;
 }
 /**
  * Next.js testing options
  * @interface NextOptions
  */
 export interface NextOptions {
-    /** Router configuration */
-    router?: Partial<unknown>;
-    /** Current pathname */
+    router?: Partial<MockNextRouter>;
     pathname?: string;
-    /** Search parameters */
     searchParams?: Record<string, string>;
-    /** Request cookies */
     cookies?: Record<string, string>;
 }
 /**
@@ -2858,83 +3065,52 @@ export interface NextOptions {
  * @interface NextTestContext
  */
 export interface NextTestContext {
-    /** Mock router instance */
-    router: unknown;
-    /** Navigation mock */
-    navigation: unknown;
-    /** Request mock */
-    req: unknown;
-    /** Response mock */
-    res: unknown;
-    /** Reset function */
+    router: MockNextRouter & NextRouterHelpers;
+    navigation: MockNextNavigationResult;
+    req: MockNextApiRequest;
+    res: MockNextApiResponse;
     reset: () => void;
 }
 /**
  * Server-side props context for testing
  * @interface SSPContext
  */
-export interface SSPContext {
-    /** Test scenario name */
+export interface SSPContext extends Partial<MockGetServerSidePropsContext> {
     scenario?: string;
-    /** Expected props */
     expectedProps?: Record<string, unknown>;
-    /** Expected redirect */
     expectedRedirect?: {
         destination: string;
         permanent?: boolean;
     };
-    /** Expect not found */
     expectNotFound?: boolean;
-    /** Request parameters */
-    params?: Record<string, string>;
-    /** Query parameters */
-    query?: Record<string, string>;
-    /** Request headers */
-    headers?: Record<string, string>;
 }
 /**
  * Static props context for testing
  * @interface SPContext
  */
-export interface SPContext {
-    /** Test scenario name */
+export interface SPContext extends Partial<MockGetStaticPropsContext> {
     scenario?: string;
-    /** Expected props */
     expectedProps?: Record<string, unknown>;
-    /** Expected revalidation time */
     expectedRevalidate?: number;
-    /** Expected redirect */
     expectedRedirect?: {
         destination: string;
         permanent?: boolean;
     };
-    /** Expect not found */
     expectNotFound?: boolean;
-    /** Route parameters */
-    params?: Record<string, string>;
 }
 /**
  * API request test configuration
  * @interface APIRequest
  */
 export interface APIRequest {
-    /** Test scenario name */
     scenario?: string;
-    /** HTTP method */
     method?: string;
-    /** Request headers */
     headers?: Record<string, string>;
-    /** Request body */
     body?: unknown;
-    /** Query parameters */
     query?: Record<string, string>;
-    /** Request cookies */
     cookies?: Record<string, string>;
-    /** Expected status code */
     expectedStatus?: number;
-    /** Expected response body */
     expectedBody?: unknown;
-    /** Expected response headers */
     expectedHeaders?: Record<string, string>;
 }
 /**
@@ -3010,6 +3186,8 @@ export interface LifecycleMetrics {
     updateTime: number;
     /** Unmount time */
     unmountTime: number;
+    totalLifecycleTime: number;
+    renderCount: number;
 }
 /**
  * File snapshot for testing
@@ -3031,14 +3209,10 @@ export interface FileSnapshot {
  * Environment configuration
  * @interface EnvConfig
  */
-export interface EnvConfig {
-    /** Base directory */
+interface EnvConfig {
     baseDir?: string;
-    /** Environment file path */
     envFile?: string;
-    /** Override existing values */
     override?: boolean;
-    /** Default values */
     defaults?: Record<string, string>;
 }
 /**
@@ -3048,11 +3222,8 @@ export interface EnvConfig {
 export interface TestEnvironment {
     /** Get environment variable */
     get: (key: string) => string | undefined;
-    /** Set environment variable */
     set: (key: string, value: string) => void;
-    /** Reset environment */
     reset: () => void;
-    /** Load environment configuration */
     load: (config: EnvConfig) => void;
 }
 /**
@@ -3062,9 +3233,7 @@ export interface TestEnvironment {
 export interface EnvMock {
     /** Restore original environment */
     restore: () => void;
-    /** Update environment variables */
     update: (vars: Record<string, string>) => void;
-    /** Clear environment variables */
     clear: () => void;
 }
 /**
@@ -3074,7 +3243,6 @@ export interface EnvMock {
 export interface EnvSnapshot {
     /** Environment variables */
     variables: Record<string, string | undefined>;
-    /** Snapshot timestamp */
     timestamp: number;
 }
 /**
@@ -3098,18 +3266,18 @@ export type ComponentType<P = Record<string, unknown>> = new (props: P) => React
  * @type GSSP
  * @typeParam T - Props type
  */
-export type GSSP<T = unknown> = (context: T) => Promise<T>;
+export type GSSP<T = unknown> = (context: MockGetServerSidePropsContext) => Promise<ServerSidePropsResult<T>>;
 /**
  * Next.js Get Static Props function
  * @type GSP
  * @typeParam T - Props type
  */
-export type GSP<T = unknown> = (context: T) => Promise<T>;
+export type GSP<T = unknown> = (context: MockGetStaticPropsContext) => Promise<StaticPropsResult<T>>;
 /**
  * Next.js API handler function
  * @type APIHandler
  */
-export type APIHandler = (req: unknown, res: unknown) => Promise<void> | void;
+export type APIHandler = (req: NextApiRequest, res: NextApiResponse) => Promise<void> | void;
 /**
  * Touch gesture type
  * @type TouchGesture
@@ -3125,11 +3293,8 @@ export type WatchCallback = (event: string, filename: string | null) => void;
  * @interface PipelineResult
  */
 export interface PipelineResult {
-    /** Output buffer */
     output: globalThis.Buffer;
-    /** Errors array */
     errors: Error[];
-    /** Duration in milliseconds */
     duration: number;
 }
 /**
@@ -3137,11 +3302,8 @@ export interface PipelineResult {
  * @interface ModuleMocks
  */
 export interface ModuleMocks {
-    /** Restore function */
     restore: () => void;
-    /** Get call count for module */
     getCallCount: (moduleName: string) => number;
-    /** Get last call for module */
     getLastCall: (moduleName: string) => unknown[];
 }
 /**
@@ -3149,12 +3311,9 @@ export interface ModuleMocks {
  * @interface AsyncHook
  */
 export interface AsyncHook {
-    /** Init callback */
     init?: (asyncId: number, type: string, triggerAsyncId: number) => void;
-    /** Before callback */
     before?: (asyncId: number) => void;
-    /** After callback */
     after?: (asyncId: number) => void;
-    /** Destroy callback */
     destroy?: (asyncId: number) => void;
 }
+export {};