@plyaz/types 1.3.2 → 1.3.3

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

@@ -0,0 +1,1970 @@
+/**
+ * @fileoverview Testing Utility Types
+ *
+ * Comprehensive type definitions for testing utilities across React, Next.js,
+ * NestJS, and general testing scenarios. Provides type safety and IntelliSense
+ * support for all testing patterns and utilities.
+ *
+ * This module includes types for:
+ * - React testing (components, hooks, providers)
+ * - Next.js testing (pages, API routes, middleware, SSR/SSG)
+ * - NestJS testing (controllers, services, modules)
+ * - Performance testing and measurement
+ * - Async testing utilities
+ * - Mock and spy configurations
+ * - Environment and configuration testing
+ * - Accessibility testing
+ * - Animation and timing testing
+ * - WebSocket and network testing
+ * - Memory and resource management
+ *
+ * @example
+ * ```typescript
+ * import type {
+ *   NextPageTestOptions,
+ *   ServiceTestHarnessOptions,
+ *   ApiRouteTestContext,
+ *   PerformanceMetrics
+ * } from './types';
+ *
+ * // Type-safe Next.js page testing
+ * const pageOptions: NextPageTestOptions = {
+ *   router: { pathname: '/test' },
+ *   mockModules: ['router', 'image']
+ * };
+ *
+ * // Type-safe NestJS service testing
+ * const serviceOptions: ServiceTestHarnessOptions<UserService> = {
+ *   Service: UserService,
+ *   dependencies: [
+ *     { token: 'UserRepository', value: mockRepository }
+ *   ]
+ * };
+ * ```
+ *
+ * @module TestingUtilityTypes
+ * @since 1.0.0
+ */
+import type * as Vitest from 'vitest';
+import type * as React from 'react';
+import type { NextApiRequest as NextJSApiRequest, NextApiResponse as NextJSApiResponse, GetStaticPathsResult as NextGetStaticPathsResult } from 'next';
+import type { Provider, Type } from '@nestjs/common';
+import type { RenderOptions as RTLRenderOptions, RenderHookOptions as RTLRenderHookOptions } from '@testing-library/react';
+import type { UserEvent as UserEventLib } from '@testing-library/user-event';
+import type { MockEventEmitter, MockNextRouter, MockGetServerSidePropsContext, MockGetStaticPropsContext, MockNextApiResponse, MockNextApiRequest, TestScenario, CreateMockUseRouterReturn, CreateMockWebSocketReturn, CreateMockNextRequestFunction } from '..';
+import type { UnknownRecord } from 'type-fest';
+/**
+ * Subscription information for tracking subscriptions in tests
+ *
+ * @typeParam T - Type of data passed to subscription callbacks
+ *
+ * @example
+ * ```typescript
+ * const info: SubscriptionInfo<UserEvent> = {
+ *   id: 'user-events-123',
+ *   callback: vi.fn((event) => console.log(event)),
+ *   unsubscribe: () => emitter.off('user', callback)
+ * };
+ * ```
+ */
+export interface SubscriptionInfo<T = unknown> {
+    /** Unique identifier for the subscription */
+    id: string;
+    /** Mocked callback function that receives subscription data */
+    callback: Vitest.MockedFunction<(data: T) => void>;
+    /** Function to unsubscribe from the event */
+    unsubscribe: () => void;
+}
+/**
+ * Generic subscription tracker interface for managing event subscriptions in tests
+ *
+ * @typeParam T - Type of data passed to subscription callbacks
+ *
+ * @example
+ * ```typescript
+ * const tracker: SubscriptionTracker<MessageEvent> = createSubscriptionTracker();
+ *
+ * // Track a subscription
+ * const sub = tracker.track(
+ *   (callback) => websocket.on('message', callback),
+ *   'ws-messages'
+ * );
+ *
+ * // Check subscription activity
+ * expect(tracker.getCallCount('ws-messages')).toBe(3);
+ * expect(tracker.getLastCall('ws-messages')).toEqual({ type: 'chat', text: 'Hello' });
+ *
+ * // Clean up
+ * tracker.unsubscribe('ws-messages');
+ * ```
+ */
+export interface SubscriptionTracker<T = unknown> {
+    /** Track a new subscription with optional ID */
+    track: (subscribeFn: (callback: (data: T) => void) => () => void, id?: string) => SubscriptionInfo<T>;
+    /** Unsubscribe a specific subscription by ID */
+    unsubscribe: (id: string) => void;
+    /** Unsubscribe all tracked subscriptions */
+    unsubscribeAll: () => void;
+    /** Get the number of times a subscription callback was called */
+    getCallCount: (id: string) => number;
+    /** Get the data from the last callback invocation */
+    getLastCall: (id: string) => T | null;
+    /** Get all data from all callback invocations */
+    getAllCalls: (id: string) => T[];
+    /** Reset all subscriptions and their call history */
+    reset: () => void;
+    /** Reset only the callback history, keeping subscriptions active */
+    resetCallbacks: () => void;
+    /** Get list of active subscription IDs */
+    getActiveSubscriptions: () => string[];
+    /** Check if a subscription is currently active */
+    hasSubscription: (id: string) => boolean;
+}
+/**
+ * Return type for createTrackedEventEmitter function
+ *
+ * @typeParam T - Type of data emitted by events
+ *
+ * @example
+ * ```typescript
+ * const emitter: CreateTrackedEventEmitterReturn<{ userId: string; action: string }> = createTrackedEventEmitter();
+ *
+ * // Subscribe to events
+ * const unsubscribe = emitter.on('user-action', (data) => {
+ *   console.log(`User ${data.userId} performed ${data.action}`);
+ * });
+ *
+ * // Emit events
+ * emitter.emit('user-action', { userId: '123', action: 'login' });
+ *
+ * // Check tracked events
+ * expect(emitter.tracker.getCallCount('default')).toBe(1);
+ * ```
+ */
+export interface CreateTrackedEventEmitterReturn<T> {
+    /** Subscribe to an event with a callback, returns unsubscribe function */
+    on: (event: string, callback: (data: T) => void) => () => void;
+    /** Emit an event with data to all listeners */
+    emit: (event: string, data: T) => void;
+    /** Remove all listeners for a specific event or all events */
+    removeAllListeners: (event?: string) => void;
+    /** Subscription tracker for monitoring event activity */
+    tracker: SubscriptionTracker<T>;
+}
+/**
+ * Deferred promise for controlling async flow in tests
+ *
+ * @typeParam T - Type of the resolved value
+ *
+ * @example
+ * ```typescript
+ * const deferred: DeferredPromise<User> = createDeferredPromise();
+ *
+ * // Start async operation
+ * const userPromise = fetchUser().then(user => {
+ *   deferred.resolve(user);
+ *   return user;
+ * });
+ *
+ * // Control when promise resolves
+ * expect(deferred.isPending).toBe(true);
+ * deferred.resolve({ id: 1, name: 'Test User' });
+ *
+ * const user = await deferred.promise;
+ * expect(deferred.isResolved).toBe(true);
+ * ```
+ */
+export interface DeferredPromise<T = void> {
+    /** The promise that can be awaited */
+    promise: Promise<T>;
+    /** Function to resolve the promise with a value */
+    resolve: (value: T) => void;
+    /** Function to reject the promise with an error */
+    reject: (error: unknown) => void;
+    /** Whether the promise has been resolved */
+    isResolved: boolean;
+    /** Whether the promise has been rejected */
+    isRejected: boolean;
+    /** Whether the promise is still pending */
+    isPending: boolean;
+}
+/**
+ * Options for wait functions
+ *
+ * @example
+ * ```typescript
+ * const options: WaitOptions = {
+ *   timeout: 5000, // 5 seconds
+ *   interval: 100, // Check every 100ms
+ *   message: 'Element did not appear in time'
+ * };
+ *
+ * await waitFor(() => document.querySelector('.loaded'), options);
+ * ```
+ */
+export interface WaitOptions {
+    /** Maximum time to wait in milliseconds (default: 5000) */
+    timeout?: number;
+    /** Polling interval in milliseconds (default: 50) */
+    interval?: number;
+    /** Custom error message if timeout is reached */
+    message?: string;
+}
+/**
+ * Options for retry operations
+ *
+ * @example
+ * ```typescript
+ * const options: RetryOptions = {
+ *   attempts: 3,
+ *   delay: 1000,
+ *   backoff: 2, // Exponential backoff
+ *   maxDelay: 10000,
+ *   shouldRetry: (error, attempt) => {
+ *     // Don't retry on 4xx errors
+ *     return error.status >= 500;
+ *   },
+ *   onRetry: (error, attempt) => {
+ *     console.log(`Retry attempt ${attempt} after error:`, error);
+ *   }
+ * };
+ *
+ * const result = await retry(() => unreliableAPI.call(), options);
+ * ```
+ */
+export interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    attempts?: number;
+    /** Initial delay between retries in ms (default: 100) */
+    delay?: number;
+    /** Backoff multiplier for exponential delay (default: 2) */
+    backoff?: number;
+    /** Maximum delay between retries in ms (default: 10000) */
+    maxDelay?: number;
+    /** Function to determine if retry should occur based on error */
+    shouldRetry?: (error: Error, attempt: number) => boolean;
+    /** Callback invoked before each retry attempt */
+    onRetry?: (error: Error, attempt: number) => void;
+}
+/**
+ * Mock async function controller for testing
+ *
+ * @typeParam T - Type of the resolved value
+ *
+ * @example
+ * ```typescript
+ * const mockFetch: MockAsync<User[]> = createMockAsync();
+ *
+ * // Use in component
+ * const users = await mockFetch.mock();
+ *
+ * // Control resolution in test
+ * expect(mockFetch.pending).toHaveLength(1);
+ * mockFetch.resolve([{ id: 1, name: 'Test' }]);
+ *
+ * // Or reject
+ * mockFetch.reject(new Error('Network error'));
+ *
+ * // Reset for next test
+ * mockFetch.reset();
+ * ```
+ */
+export interface MockAsync<T = void> {
+    /** The mock function that returns promises */
+    mock: Vitest.Mock;
+    /** Resolve the next pending promise with a value */
+    resolve: (value: T) => void;
+    /** Reject the next pending promise with an error */
+    reject: (error: unknown) => void;
+    /** Reset the mock and clear all pending promises */
+    reset: () => void;
+    /** Array of currently pending promises */
+    pending: DeferredPromise<T>[];
+}
+/**
+ * Controllable timer for testing time-dependent operations
+ *
+ * @example
+ * ```typescript
+ * const timer: ControllableTimer = createControllableTimer();
+ *
+ * timer.start();
+ * await performOperation();
+ * timer.stop();
+ *
+ * expect(timer.elapsed).toBeLessThan(1000);
+ *
+ * // Simulate time passing
+ * timer.tick(500);
+ * expect(timer.elapsed).toBe(500);
+ * ```
+ */
+export interface ControllableTimer {
+    /** Start the timer */
+    start: () => void;
+    /** Stop the timer */
+    stop: () => void;
+    /** Manually advance the timer by specified milliseconds */
+    tick: (ms: number) => void;
+    /** Reset the timer to zero */
+    reset: () => void;
+    /** Get elapsed time in milliseconds */
+    elapsed: number;
+}
+/**
+ * Test-friendly event emitter with async support
+ *
+ * @typeParam T - Type of data emitted
+ *
+ * @example
+ * ```typescript
+ * const emitter: TestEventEmitter<UserEvent> = createTestEventEmitter();
+ *
+ * // Listen for events
+ * const unsubscribe = emitter.on((event) => {
+ *   console.log('User event:', event);
+ * });
+ *
+ * // Emit synchronously
+ * emitter.emit({ type: 'login', userId: '123' });
+ *
+ * // Emit and wait for async handlers
+ * await emitter.emitAsync({ type: 'logout', userId: '123' });
+ *
+ * // Wait for next event
+ * const nextEvent = await emitter.waitForEvent(5000);
+ * ```
+ */
+export interface TestEventEmitter<T = unknown> {
+    /** Add event listener, returns unsubscribe function */
+    on: (handler: (data: T) => void) => () => void;
+    /** Add one-time event listener, returns unsubscribe function */
+    once: (handler: (data: T) => void) => () => void;
+    /** Emit event synchronously to all listeners */
+    emit: (data: T) => void;
+    /** Emit event and wait for all async handlers to complete */
+    emitAsync: (data: T) => Promise<void>;
+    /** Remove all event listeners */
+    removeAllListeners: () => void;
+    /** Get current number of listeners */
+    listenerCount: () => number;
+    /** Wait for the next event with optional timeout */
+    waitForEvent: (timeout?: number) => Promise<T>;
+}
+/**
+ * Step in an async test sequence
+ *
+ * @typeParam T - Type of value returned by the step
+ *
+ * @example
+ * ```typescript
+ * const steps: AsyncTestStep<any>[] = [
+ *   {
+ *     name: 'Initialize database',
+ *     action: () => db.connect(),
+ *     delay: 100
+ *   },
+ *   {
+ *     name: 'Create user',
+ *     action: () => db.users.create({ name: 'Test' }),
+ *     assertion: (user) => expect(user.id).toBeDefined()
+ *   },
+ *   {
+ *     name: 'Cleanup',
+ *     action: () => db.disconnect(),
+ *     onError: (error) => console.error('Cleanup failed:', error)
+ *   }
+ * ];
+ * ```
+ */
+export interface AsyncTestStep<T = unknown> {
+    /** Descriptive name for the step */
+    name: string;
+    /** Function to execute for this step */
+    action: () => Promise<T> | T;
+    /** Optional delay before executing this step (ms) */
+    delay?: number;
+    /** Optional assertion to run after step completes */
+    assertion?: (result: T) => void | Promise<void>;
+    /** Optional error handler for this step */
+    onError?: (error: Error) => void;
+}
+/**
+ * Options for testing concurrent operations
+ *
+ * @example
+ * ```typescript
+ * const options: ConcurrentTestOptions = {
+ *   operations: [
+ *     () => api.uploadFile('file1.txt'),
+ *     () => api.uploadFile('file2.txt'),
+ *     () => api.uploadFile('file3.txt')
+ *   ],
+ *   maxConcurrency: 2, // Only 2 uploads at a time
+ *   timeout: 30000, // 30 second timeout
+ *   expectErrors: false // Fail if any operation throws
+ * };
+ *
+ * const result = await testConcurrentOperations(options);
+ * ```
+ */
+export interface ConcurrentTestOptions {
+    /** Array of async operations to execute */
+    operations: Array<() => Promise<unknown>>;
+    /** Maximum number of operations to run simultaneously */
+    maxConcurrency?: number;
+    /** Timeout for all operations in milliseconds */
+    timeout?: number;
+    /** Whether to expect some operations to fail */
+    expectErrors?: boolean;
+}
+/**
+ * Options for testing rate-limited operations
+ *
+ * @example
+ * ```typescript
+ * const options: RateLimitTestOptions = {
+ *   operation: () => api.getData(),
+ *   requestsPerSecond: 10,
+ *   duration: 5000, // Test for 5 seconds
+ *   expectThrottle: true // Expect some requests to be throttled
+ * };
+ *
+ * const result = await testRateLimit(options);
+ * expect(result.actualRate).toBeLessThan(10);
+ * ```
+ */
+export interface RateLimitTestOptions {
+    /** The operation to test for rate limiting */
+    operation: () => Promise<unknown>;
+    /** Target requests per second */
+    requestsPerSecond: number;
+    /** How long to run the test in milliseconds */
+    duration: number;
+    /** Whether to expect throttling to occur */
+    expectThrottle?: boolean;
+}
+/**
+ * State transition for testing state machines
+ *
+ * @typeParam T - Type of state object
+ *
+ * @example
+ * ```typescript
+ * const transitions: StateTransition<LoadingState>[] = [
+ *   {
+ *     from: { status: 'idle', data: null },
+ *     to: { status: 'loading', data: null },
+ *     action: () => store.dispatch(fetchData())
+ *   },
+ *   {
+ *     from: { status: 'loading', data: null },
+ *     to: { status: 'success', data: expect.any(Array) },
+ *     action: () => mockApi.resolveWith([1, 2, 3]),
+ *     delay: 100
+ *   }
+ * ];
+ * ```
+ */
+export interface StateTransition<T> {
+    /** Expected state before transition */
+    from: T;
+    /** Expected state after transition */
+    to: T;
+    /** Action that triggers the transition */
+    action: () => Promise<void> | void;
+    /** Optional delay after action before checking state */
+    delay?: number;
+}
+/**
+ * Expected sequence of events for testing
+ *
+ * @example
+ * ```typescript
+ * const sequence: EventSequence = {
+ *   events: ['connect', 'authenticate', 'ready'],
+ *   strict: true // Events must occur in exact order
+ * };
+ *
+ * const tracker = createEventSequenceTracker(sequence);
+ * ```
+ */
+export interface EventSequence {
+    /** Expected event names in order */
+    events: string[];
+    /** Whether events must occur in exact order (default: true) */
+    strict?: boolean;
+}
+/**
+ * Cleanup operation for async resource management
+ *
+ * @example
+ * ```typescript
+ * const cleanupItems: AsyncCleanupItem[] = [
+ *   {
+ *     name: 'Close database',
+ *     cleanup: () => db.close(),
+ *     timeout: 5000
+ *   },
+ *   {
+ *     name: 'Stop server',
+ *     cleanup: async () => {
+ *       await server.stop();
+ *       await server.waitForClose();
+ *     },
+ *     timeout: 10000
+ *   }
+ * ];
+ * ```
+ */
+export interface AsyncCleanupItem {
+    /** Descriptive name for the cleanup operation */
+    name: string;
+    /** Cleanup function to execute */
+    cleanup: () => Promise<void> | void;
+    /** Optional timeout for cleanup operation */
+    timeout?: number;
+}
+/**
+ * Options for testing polling behavior
+ *
+ * @example
+ * ```typescript
+ * const options: PollingTestOptions = {
+ *   pollFn: () => api.getJobStatus(jobId),
+ *   condition: (result) => result.status === 'completed',
+ *   maxAttempts: 20,
+ *   interval: 1000,
+ *   onPoll: (attempt, result) => {
+ *     console.log(`Attempt ${attempt}: ${result.status}`);
+ *   }
+ * };
+ *
+ * const result = await testPolling(options);
+ * ```
+ */
+export interface PollingTestOptions {
+    /** Function to call on each poll */
+    pollFn: () => Promise<unknown> | unknown;
+    /** Condition to check if polling should stop */
+    condition: (result: unknown) => boolean;
+    /** Maximum number of polling attempts */
+    maxAttempts?: number;
+    /** Interval between polls in milliseconds */
+    interval?: number;
+    /** Callback invoked after each poll */
+    onPoll?: (attempt: number, result: unknown) => void;
+}
+export interface TestCleanup {
+    add: (cleanup: () => void | Promise<void>) => void;
+    runAll: () => Promise<void>;
+    clear: () => void;
+}
+export interface MockConsole {
+    log: Vitest.Mock;
+    error: Vitest.Mock;
+    warn: Vitest.Mock;
+    info: Vitest.Mock;
+    debug: Vitest.Mock;
+    restore: () => void;
+}
+export interface MockEnv {
+    set: (key: string, value: string) => void;
+    get: (key: string) => string | undefined;
+    delete: (key: string) => void;
+    clear: () => void;
+    restore: () => void;
+}
+export interface TestDataCleanup<T> {
+    register: (data: T) => T;
+    cleanup: () => Promise<void>;
+    getAll: () => T[];
+}
+export type RenderOptions = RTLRenderOptions;
+export type RenderHookOptions<TProps> = RTLRenderHookOptions<TProps>;
+export type SpyInstance = Vitest.MockedFunction<(...args: unknown[]) => unknown>;
+export interface BenchmarkOptions {
+    iterations?: number;
+    time?: number;
+    warmup?: number;
+    setup?: () => void | Promise<void>;
+    teardown?: () => void | Promise<void>;
+    runs?: number;
+    format?: 'table' | 'json';
+}
+export interface TestBedConfig {
+    providers: Provider[];
+    imports?: unknown[];
+    exports?: unknown[];
+}
+export interface ControllerTestHarnessOptions<T> {
+    Controller: Type<T>;
+    dependencies?: Array<{
+        token: unknown;
+        value: unknown;
+    }>;
+    mockLogger?: boolean;
+}
+export interface ValidateMiddlwareResponseExpected {
+    type: 'next' | 'redirect' | 'rewrite' | 'response';
+    url?: string;
+    status?: number;
+}
+export interface ServiceTestHarnessOptions<T> {
+    Service: Type<T>;
+    dependencies?: Array<{
+        token: unknown;
+        value: unknown;
+    }>;
+    mockLogger?: boolean;
+}
+export type NestModule = Type<unknown>;
+export interface ModuleTestHarnessOptions {
+    Module: NestModule;
+    overrideProviders?: Array<{
+        token: unknown;
+        useValue?: unknown;
+        useFactory?: (...args: unknown[]) => unknown;
+    }>;
+}
+export interface NextPageTestOptions extends RenderOptions {
+    router?: Partial<MockNextRouter>;
+    mockModules?: Array<'router' | 'image' | 'link' | 'head'>;
+}
+export type NextApiRequest = NextJSApiRequest;
+export type NextApiResponse = NextJSApiResponse;
+export interface ApiRouteTestContext {
+    req: NextApiRequest;
+    res: NextApiResponse;
+    expectStatus: (status: number) => void;
+    expectJson: (data: unknown) => void;
+    expectRedirect: (url: string, status?: number) => void;
+    expectHeader: (name: string, value: string | string[]) => void;
+}
+export interface MiddlewareTestContext {
+    request: Request;
+    event: {
+        request: Request;
+        waitUntil: (promise: Promise<unknown>) => void;
+    };
+    expectRedirect: (url: string) => void;
+    expectRewrite: (url: string) => void;
+    expectHeader: (name: string, value: string) => void;
+    expectNext: () => void;
+}
+export interface AppRouterHookTestOptions<TProps> extends RenderHookOptions<TProps> {
+    pathname?: string;
+    searchParams?: Record<string, string | string[]>;
+    params?: Record<string, string | string[]>;
+}
+export type UserEvent = UserEventLib;
+export interface UserEventConfig {
+    delay?: number;
+    advanceTimers?: (ms: number) => void | Promise<void>;
+    applyAccept?: boolean;
+    autoModify?: boolean;
+    skipAutoClose?: boolean;
+    writeToClipboard?: boolean;
+}
+export interface InteractionSequence {
+    type: 'click' | 'type' | 'select' | 'check' | 'focus' | 'blur' | 'hover' | 'key' | 'paste' | 'clear' | 'upload' | 'drag' | 'scroll' | 'wait' | 'tab' | 'keyboard';
+    target?: string | HTMLElement;
+    value?: string | string[] | boolean | File | File[];
+    wait?: number;
+    options?: {
+        delay?: number;
+        position?: {
+            x: number;
+            y: number;
+        };
+        key?: string;
+        modifiers?: Array<'Shift' | 'Control' | 'Alt' | 'Meta'>;
+        skipClick?: boolean;
+        skipHover?: boolean;
+        scrollIntoView?: boolean;
+        force?: boolean;
+        timeout?: number;
+        waitForElement?: boolean;
+        direction?: 'up' | 'down' | 'left' | 'right';
+        distance?: number;
+    };
+}
+export interface MockChildProcessInstance {
+    stdout: {
+        on: {
+            mock: {
+                calls: Array<[string, Function]>;
+            };
+        };
+    };
+    stderr: {
+        on: {
+            mock: {
+                calls: Array<[string, Function]>;
+            };
+        };
+    };
+    on: {
+        mock: {
+            calls: Array<[string, Function]>;
+        };
+    };
+    [key: string]: unknown;
+}
+export interface ProcessTestUtils {
+    simulateSignal: (signal: string) => void;
+    expectExit: (code?: number) => void;
+    captureOutput: () => {
+        stdout: string[];
+        stderr: string[];
+    };
+    simulateUncaughtException: (error: Error) => void;
+    simulateUnhandledRejection: (reason: unknown) => void;
+}
+export interface ChildProcessTestUtils {
+    expectCommand: (command: string, args?: string[]) => void;
+    simulateOutput: (stdout: string, stderr?: string) => void;
+    simulateError: (error: Error) => void;
+    simulateExit: (code: number) => void;
+    getLastProcess: () => unknown;
+}
+export interface StreamTestUtils {
+    pipeData: (data: string | globalThis.Buffer) => void;
+    endStream: () => void;
+    expectPipedTo: (destination: unknown) => void;
+    getWrittenData: () => Array<string | globalThis.Buffer>;
+}
+export interface EventDrivenTestUtils {
+    emitter: MockEventEmitter;
+    expectEvent: (event: string, payload?: unknown) => void;
+    expectNoEvent: (event: string) => void;
+    simulateEvents: (events: Array<SimulatedEvent>) => Promise<void>;
+    getEventHistory: () => Array<EventHistoryEntry>;
+}
+export interface TestServer {
+    url: string;
+    port: number;
+    close: () => Promise<void>;
+    on: (event: string, handler: Function) => void;
+}
+export interface ConcurrentOperationResult {
+    success: boolean;
+    result?: unknown;
+    error?: Error;
+    duration: number;
+}
+export interface ConcurrentTestResult {
+    results: ConcurrentOperationResult[];
+    totalDuration: number;
+    successCount: number;
+    errorCount: number;
+    averageDuration: number;
+}
+export interface RateLimitResult {
+    timestamp: number;
+    success: boolean;
+    error?: Error;
+}
+export interface RateLimitTestResult {
+    results: RateLimitResult[];
+    actualRate: number;
+    wasThrottled: boolean;
+}
+export interface PollingAttempt {
+    attempt: number;
+    result: unknown;
+    timestamp: number;
+}
+export interface PollingTestResult {
+    attempts: PollingAttempt[];
+    conditionMet: boolean;
+    totalAttempts: number;
+    totalDuration: number;
+}
+export interface DebounceTestResult {
+    callCount: number;
+    lastCallTime: number;
+}
+export interface ThrottleCall {
+    args: unknown[];
+    delay: number;
+}
+export interface ThrottleResult {
+    called: boolean;
+    args?: unknown[];
+}
+export interface AsyncScenario<T> {
+    name: string;
+    setup: () => Promise<void>;
+    action: () => Promise<T>;
+    verify: (result: T) => void | Promise<void>;
+    cleanup?: () => Promise<void>;
+}
+export interface WaitForChangeOptions<T> {
+    timeout?: number;
+    interval?: number;
+    compareFn?: (a: T, b: T) => boolean;
+}
+export interface PerformanceMetrics {
+    min: number;
+    max: number;
+    mean: number;
+    median: number;
+    p95: number;
+    p99: number;
+    runs: number[];
+}
+export interface MeasureTimeOptions {
+    warmup?: number;
+    runs?: number;
+}
+export interface MeasureTimeResult<T> {
+    result: T;
+    duration: number;
+    metrics?: PerformanceMetrics;
+}
+export interface BenchmarkResult {
+    [functionName: string]: PerformanceMetrics;
+}
+export interface LoadTestOptions {
+    duration?: number;
+    concurrency?: number;
+    rampUp?: number;
+    onProgress?: (stats: LoadTestStats) => void;
+}
+export interface LoadTestStats {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    latencies: number[];
+    errors: Error[];
+}
+export interface LoadTestResult {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    averageLatency: number;
+    throughput: number;
+    errors: Error[];
+}
+export interface ProfileCPUOptions {
+    sampleInterval?: number;
+}
+export interface CPUProfile {
+    samples: number[];
+    duration: number;
+}
+export interface ProfileCPUResult<T> {
+    result: T;
+    profile: CPUProfile;
+}
+export interface ScalabilityTestOptions {
+    expectedComplexity?: 'constant' | 'logarithmic' | 'linear' | 'quadratic';
+    tolerance?: number;
+}
+export interface ScalabilityMeasurement {
+    size: number;
+    time: number;
+}
+export interface ScalabilityTestResult {
+    measurements: ScalabilityMeasurement[];
+    complexity: string;
+    isWithinExpected: boolean;
+}
+export interface PerformanceComparisonOptions {
+    runs?: number;
+    chart?: boolean;
+}
+export interface PerformanceComparisonInput<T> {
+    name: string;
+    value: T;
+}
+export interface MemoryMeasurement {
+    before: number;
+    after: number;
+    delta: number;
+    peak: number;
+}
+export interface MeasureMemoryOptions {
+    forceGC?: boolean;
+    runs?: number;
+}
+export interface MeasureMemoryResult<T> {
+    result: T;
+    memory: MemoryMeasurement;
+}
+export interface PerformanceConstraints {
+    maxTime?: number;
+    maxMemory?: number;
+    minThroughput?: number;
+}
+export interface AssertPerformanceOptions {
+    runs?: number;
+    duration?: number;
+}
+export interface EventHistoryEntry {
+    event: string;
+    payload: unknown;
+    timestamp: number;
+}
+export interface SimulatedEvent {
+    event: string;
+    payload?: unknown;
+    delay?: number;
+}
+export interface WebSocketMockOptions {
+    url?: string;
+    protocol?: string;
+    extensions?: string;
+    readyState?: number;
+    bufferedAmount?: number;
+}
+export interface WebSocketServerMockOptions {
+    port?: number;
+    host?: string;
+    maxClients?: number;
+}
+export interface WebSocketTestScenario {
+    name: string;
+    message: unknown;
+    expectedResponse?: unknown;
+    expectedBroadcast?: unknown;
+    shouldError?: boolean;
+    errorMessage?: string;
+}
+export interface WebSocketConnectionOptions {
+    url: string;
+    protocols?: string | string[];
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+export interface FileOperationTest {
+    name: string;
+    operation: (fs: unknown) => void | Promise<void>;
+    expectedFiles?: Map<string, string | globalThis.Buffer>;
+    expectedError?: string | RegExp;
+}
+export interface SignalTest {
+    signal: string;
+    expectedBehavior: () => void;
+}
+export interface AriaAttributes {
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+    ariaExpanded?: boolean;
+    ariaHidden?: boolean;
+    ariaLive?: 'off' | 'polite' | 'assertive';
+    ariaAtomic?: boolean;
+    ariaBusy?: boolean;
+    ariaChecked?: boolean;
+    ariaDisabled?: boolean;
+    ariaInvalid?: boolean;
+    ariaPressed?: boolean;
+    ariaReadonly?: boolean;
+    ariaRequired?: boolean;
+    ariaSelected?: boolean;
+    role?: string;
+    tabIndex?: number;
+}
+export interface KeyboardNavigationTest {
+    element: HTMLElement;
+    key: string;
+    expectedBehavior: 'focus' | 'activate' | 'navigate' | 'ignore';
+    expectedTarget?: HTMLElement;
+}
+export interface ScreenReaderTest {
+    element: HTMLElement;
+    expectedText: string | RegExp;
+    includeHidden?: boolean;
+}
+export interface LifecycleHook {
+    name: string;
+    method: string;
+    phase: 'mount' | 'update' | 'unmount' | 'init' | 'destroy';
+    required?: boolean;
+    async?: boolean;
+}
+export interface ComponentLifecycleTest {
+    name: string;
+    Component: React.ComponentType<unknown>;
+    props?: Record<string, unknown>;
+    expectedHooks: LifecycleHook[];
+    interactions?: Array<{
+        action: () => void | Promise<void>;
+        expectedHooksAfter: string[];
+    }>;
+}
+export interface ServiceWithLifecycle {
+    onModuleInit?: () => Promise<void>;
+    onModuleDestroy?: () => Promise<void>;
+    onApplicationBootstrap?: () => Promise<void>;
+    onApplicationShutdown?: () => Promise<void>;
+    [key: string]: unknown;
+}
+export interface ServiceLifecycleTest {
+    name: string;
+    Service: new (...args: unknown[]) => ServiceWithLifecycle;
+    dependencies?: unknown[];
+    expectedHooks: LifecycleHook[];
+    cleanupExpected?: boolean;
+}
+export interface ProviderWithLifecycle {
+    constructor: {
+        name: string;
+    };
+    onModuleInit?: () => Promise<void>;
+    onModuleDestroy?: () => Promise<void>;
+    [key: string]: unknown;
+}
+export interface ModuleLifecycleTest {
+    name: string;
+    Module: new (...args: unknown[]) => unknown;
+    providers: ProviderWithLifecycle[];
+    expectedInitOrder: string[];
+    expectedDestroyOrder: string[];
+}
+export interface ApplicationLifecycleTest {
+    name: string;
+    app: Record<string, unknown>;
+    modules: unknown[];
+    expectedStartupSequence: string[];
+    expectedShutdownSequence: string[];
+}
+export interface TestSuiteConfig<T> {
+    name: string;
+    createInstance: () => T;
+    defaultProps?: unknown;
+    setupBeforeAll?: () => void | Promise<void>;
+    setupBeforeEach?: () => void | Promise<void>;
+    teardownAfterEach?: () => void | Promise<void>;
+    teardownAfterAll?: () => void | Promise<void>;
+}
+export interface EnvironmentConfig {
+    [key: string]: string | undefined;
+}
+export interface AnimationTestOptions {
+    duration?: number;
+    easing?: string;
+    delay?: number;
+    iterations?: number;
+    direction?: 'normal' | 'reverse' | 'alternate' | 'alternate-reverse';
+    fillMode?: 'none' | 'forwards' | 'backwards' | 'both';
+}
+export interface TransitionTestOptions {
+    property?: string;
+    duration?: number;
+    timingFunction?: string;
+    delay?: number;
+}
+export interface KeyframeTest {
+    percentage: number;
+    styles: Record<string, string>;
+}
+export interface AnimationSequence {
+    name: string;
+    steps: Array<{
+        delay?: number;
+        duration: number;
+        styles: Record<string, string>;
+        easing?: string;
+    }>;
+}
+export interface EnvironmentTestCase {
+    name: string;
+    environment: EnvironmentConfig;
+    expectedBehavior: () => void | Promise<void>;
+    cleanup?: () => void | Promise<void>;
+}
+export interface ConfigTestScenario {
+    name: string;
+    config: Record<string, unknown>;
+    environment?: EnvironmentConfig;
+    expectedValues: Record<string, unknown>;
+    shouldThrow?: boolean;
+    expectedError?: string | RegExp;
+}
+export interface SpringConfig {
+    tension: number;
+    friction: number;
+    mass: number;
+}
+export interface RAFCallback {
+    id: number;
+    callback: FrameRequestCallback;
+}
+export interface LoadingState {
+    isLoading?: boolean;
+    loading?: boolean;
+}
+export interface ForTextOptions {
+    timeout?: number;
+}
+export interface TestValueWithIndex<T> {
+    value: T;
+    index: number;
+}
+export interface CallRecord {
+    method: string;
+    args: unknown[];
+    timestamp: number;
+}
+export interface ModuleSpy<T> {
+    module: T;
+    calls: CallRecord[];
+}
+export interface NamedTestCase<T> {
+    name: string;
+    input: T;
+    expected: unknown;
+}
+export type NodeTimeout = ReturnType<typeof globalThis.setTimeout>;
+export interface NavigationOptions {
+    shallow?: boolean;
+}
+export interface ImageLoaderProps {
+    src: string;
+    width: number;
+    quality?: number;
+}
+export interface PerformanceMemory {
+    memory?: {
+        usedJSHeapSize: number;
+    };
+}
+export interface NextPageResult {
+    props?: unknown;
+    redirect?: {
+        destination: string;
+        permanent?: boolean;
+        statusCode?: number;
+    };
+    notFound?: boolean;
+}
+export interface MockCallResult {
+    args: unknown[];
+    result: unknown;
+    error?: unknown;
+}
+export interface FileWatcher extends MockEventEmitter {
+    add: Vitest.Mock;
+    unwatch: Vitest.Mock;
+    close: Vitest.Mock;
+    getWatched: Vitest.Mock;
+    simulateChange: (path: string) => void;
+    simulateAdd: (path: string) => void;
+    simulateUnlink: (path: string) => void;
+}
+export interface NestJSTestBed {
+    get: <T>(token: unknown) => T;
+    close: () => Promise<void>;
+    moduleRef: Map<unknown, unknown>;
+}
+export interface ModuleTestHarness {
+    moduleRef: {
+        get: <T>(token: unknown) => T;
+        close: () => Promise<void>;
+        moduleRef: Map<unknown, unknown>;
+    };
+    get: <T>(token: unknown) => T;
+    close: () => Promise<void>;
+}
+export interface NextRouterHelpers {
+    navigateTo: (url: string, options?: NavigationOptions) => Promise<void>;
+    simulateRouteChange: (fromUrl: string, toUrl: string) => void;
+    simulateRouteError: (url: string, error: Error) => void;
+    expectNavigation: (url: string, type?: 'push' | 'replace') => void;
+    expectNoNavigation: () => void;
+}
+export interface MockNextRouterReturn {
+    router: MockNextRouter;
+    useRouter: CreateMockUseRouterReturn;
+    restore: () => void;
+}
+export interface MockNextRequest {
+    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;
+    };
+}
+export interface MockNextResponse {
+    cookies: {
+        set: Vitest.Mock;
+        delete: Vitest.Mock;
+    };
+    headers: Headers;
+    status: number;
+    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.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;
+}
+export interface MockWebSocketGlobal {
+    restore: () => void;
+}
+export interface MockSystemDateReturn {
+    setDate: (newDate: Date | string | number) => void;
+    advanceBy: (ms: number) => void;
+}
+export type GetStaticPathsResult = NextGetStaticPathsResult;
+export interface GetStaticPathsExpectations {
+    pathCount?: number;
+    fallback: boolean | 'blocking';
+    validatePaths?: (paths: Array<string | {
+        params: Record<string, string | string[] | undefined>;
+    }>) => void;
+}
+export interface ImageOptimizationScenario {
+    src: string;
+    width: number;
+    quality?: number;
+    expectedUrl: string;
+    alt: string;
+    priority?: boolean;
+    height?: number;
+}
+export interface DragAndDropOptions {
+    dragData?: Record<string, string>;
+    expectedDropEffect?: 'copy' | 'move' | 'link' | 'none';
+}
+export interface TypeRealisticOptions {
+    pauseBetweenChars?: number;
+    typos?: boolean;
+    speed?: 'slow' | 'normal' | 'fast';
+}
+export interface LoadingComponentExpectations {
+    testId?: string;
+    text?: string;
+    className?: string;
+}
+export interface MiddlewareTestScenarioWithRequest {
+    name: string;
+    request: Parameters<CreateMockNextRequestFunction>;
+    expected: {
+        type: 'next' | 'redirect' | 'rewrite' | 'response';
+        url?: string;
+        headers?: Record<string, string>;
+        status?: number;
+    };
+}
+export interface ApiRouteHandlerMethods {
+    GET?: Function;
+    POST?: Function;
+    PUT?: Function;
+    DELETE?: Function;
+    PATCH?: Function;
+}
+export interface RouteHandlerTestScenario {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    request: Parameters<CreateMockNextRequestFunction>;
+    expectedStatus: number;
+    expectedBody?: unknown;
+}
+export interface ImageLoaderTestScenario {
+    input: ImageLoaderInput;
+    expectedUrl: string | RegExp;
+}
+export interface ParameterizedTest<T> {
+    test: (name: string, fn: (input: T, expected: unknown) => void | Promise<void>) => void;
+}
+export interface ServiceTestSuite<T> {
+    testMethods: () => void;
+    testErrorHandling: (errorScenarios: Array<ErrorScenario<T>>) => void;
+}
+export interface NestJSTestSuiteReturn {
+    testProviderRegistration: (providerTokens: unknown[]) => void;
+    testProviderInjection: (injectionTests: Array<ProviderInjectionTest>) => void;
+}
+export interface NextJSTestSuite {
+    testStaticGeneration: (getStaticProps?: Function, getStaticPaths?: Function) => void;
+    testServerSideRendering: (getServerSideProps?: Function) => void;
+    testPageRendering: (scenarios: Array<PropsTestScenario>) => void;
+}
+export interface TestSuiteFactory<T extends UnknownRecord> {
+    runScenarios: (scenarios: TestScenario<T, unknown, unknown>[]) => void;
+    testMethod: (methodName: keyof T, testCases: Array<TestCaseWithSetup<T>>) => void;
+    testLifecycle: (lifecycleHooks: Array<LifecycleHookTestConfig<T>>) => void;
+    testErrorHandling: (errorScenarios: Array<ErrorHandlingScenario<T>>) => void;
+}
+export interface ConditionalMockBehavior<T> {
+    predicate: (...args: unknown[]) => boolean;
+    result: T | (() => T);
+}
+export interface MockModuleResult {
+    unmock: () => void;
+}
+export interface MockManyResult {
+    unmockAll: () => void;
+}
+export interface RouteMatchResult {
+    params: Record<string, string | string[]>;
+    isMatch: boolean;
+}
+export interface PerformanceEntryResult {
+    name: string;
+    metrics: PerformanceMetrics;
+}
+export interface MemoryMeasurementResult<T> {
+    measurement: MemoryMeasurement;
+    result: T;
+}
+export interface GlobalWithGC {
+    gc?: () => void;
+}
+export interface MemoryLeakTestResult {
+    initialMemory: number;
+    finalMemory: number;
+    memoryIncrease: number;
+    iterations: number;
+}
+export interface PropVariation {
+    name: string;
+    props: Record<string, unknown>;
+    expectation: () => void;
+}
+export interface ValidTestCase<T> {
+    name: string;
+    input: unknown;
+    expected?: T;
+}
+export interface InvalidTestCase {
+    name: string;
+    input: unknown;
+    expectedError: string | RegExp;
+}
+export interface CreatedResource {
+    name: string;
+    resource: unknown;
+}
+export interface LifecycleHookRecord {
+    phase: string;
+    method: string;
+    timestamp: number;
+}
+export interface PathMatchTest {
+    path: string;
+    shouldMatch: boolean;
+}
+export interface ErrorScenario<T> {
+    method: string;
+    setup: (service: T) => void;
+    expectedError: unknown;
+}
+export interface PropsTestScenario {
+    props: Record<string, unknown>;
+    expectedContent?: string;
+}
+export interface ResponsiveBreakpoint {
+    width: number;
+    height: number;
+    expectations: () => void;
+}
+export type TestCombination<T extends Record<string, unknown[]>> = {
+    [K in keyof T]: T[K][number];
+};
+export interface TestDependency {
+    token: unknown;
+    value: unknown;
+}
+export type LoadingResult = {
+    current: LoadingState;
+} | {
+    result: {
+        current: LoadingState;
+    };
+};
+export interface TableTestCase<TInput, TExpected> {
+    name: string;
+    input: TInput;
+    expected: TExpected;
+    skip?: boolean;
+    only?: boolean;
+    error?: boolean;
+}
+export interface EdgeCaseTest<T, R> {
+    name: string;
+    input: T;
+    expected?: R;
+    shouldThrow?: string | RegExp | Error;
+}
+export interface AnimationPerformanceMetrics {
+    avgFrameTime: number;
+    avgFPS: number;
+    maxFrameTime: number;
+    minFrameTime: number;
+    frameTimes: number[];
+}
+export interface AnimationPerformanceOptions {
+    iterations?: number;
+    maxFrameTime?: number;
+    minFPS?: number;
+}
+export type ServerSidePropsResult<T> = {
+    props: T;
+} | {
+    redirect: unknown;
+} | {
+    notFound: true;
+};
+export type StaticPropsResult<T> = {
+    props: T;
+    revalidate?: number;
+} | {
+    redirect: unknown;
+} | {
+    notFound: true;
+};
+export interface ServerSidePropsTestResult<T> {
+    result: ServerSidePropsResult<T>;
+    context: MockGetServerSidePropsContext;
+    expectProps: (props: Partial<T>) => void;
+    expectRedirect: (destination: string, permanent?: boolean) => void;
+    expectNotFound: () => void;
+}
+export interface StaticPropsTestResult<T> {
+    result: StaticPropsResult<T>;
+    context: MockGetStaticPropsContext;
+    expectProps: (props: Partial<T>) => void;
+    expectRedirect: (destination: string, permanent?: boolean) => void;
+    expectNotFound: () => void;
+    expectRevalidate: (seconds: number) => void;
+}
+export interface CreateCustomQueriesReturn {
+    getByClassName: (className: string) => HTMLElement;
+    getAllByClassName: (className: string) => HTMLElement[];
+    getByAttribute: (attribute: string, value?: string) => HTMLElement;
+}
+export interface BoundaryValueTest<T> {
+    value: T;
+    description: string;
+    expected: unknown;
+}
+export interface EquivalenceClassTest<T, R> {
+    name: string;
+    samples: T[];
+    expected: R;
+}
+export interface StateTransitionTest<TState, TAction> {
+    from: TState;
+    action: TAction;
+    to: TState;
+    description?: string;
+}
+export interface SnapshotTestCase<T> {
+    name: string;
+    input: T;
+    transform?: (input: T) => unknown;
+}
+export interface CombinationTestOptions<T extends Record<string, unknown[]>> {
+    filter?: (combination: TestCombination<T>) => boolean;
+    maxCombinations?: number;
+}
+export interface FuzzyTestOptions<T, R> {
+    generateInput: () => T;
+    fn: (input: T) => R;
+    invariant: (input: T, output: R) => boolean;
+    options?: {
+        iterations?: number;
+        seed?: number;
+    };
+}
+export interface PropertyTestOptions {
+    runs?: number;
+    seed?: number;
+    onFailure?: (value: unknown, index: number) => void;
+}
+export interface AnimationCheckpoint {
+    progress: number;
+    expectedState: () => void;
+}
+export interface ParallaxElement {
+    element: HTMLElement;
+    speed: number;
+}
+export interface SpringAnimationConfigTest {
+    name: string;
+    tension: number;
+    friction: number;
+    mass: number;
+    expectedDuration: number;
+}
+export interface AnimationStateMachine {
+    currentState: string;
+    transition: (to: string) => Promise<void>;
+    getState: () => string;
+}
+export interface AnimationStateTransition {
+    from: string;
+    to: string;
+    duration: number;
+    isValid: boolean;
+}
+export interface AnimationTestUtils {
+    tick: (deltaTime?: number) => void;
+    advanceTime: (time: number) => void;
+    restore: () => void;
+    getPendingCallbacks: () => number;
+}
+export interface EnvironmentManager {
+    set: (env: EnvironmentConfig) => void;
+    merge: (env: EnvironmentConfig) => void;
+    unset: (keys: string[]) => void;
+    restore: () => void;
+    reset: () => void;
+    getCurrent: () => EnvironmentConfig;
+    has: (key: string) => boolean;
+    get: (key: string, defaultValue?: string) => string | undefined;
+    clearAll: () => void;
+}
+export interface EnvironmentHooks {
+    setup: () => void;
+    teardown: () => void;
+    getManager: () => EnvironmentManager;
+    useEnvironment: (env: EnvironmentConfig) => void;
+}
+export interface EnvironmentValidationTestCase {
+    name: string;
+    environment: EnvironmentConfig;
+    shouldPass: boolean;
+    expectedErrors?: string[];
+}
+export interface EnvironmentFeatureFlagScenario {
+    environment: EnvironmentConfig;
+    flag: string;
+    defaultValue?: boolean;
+    expectedValue: boolean;
+}
+export interface DatabaseEnvironmentTest {
+    name: string;
+    environment: EnvironmentConfig;
+    expectedConfig: Record<string, unknown>;
+    shouldConnect: boolean;
+}
+export interface LoggingEnvironmentTest {
+    name: string;
+    environment: EnvironmentConfig;
+    expectedLevel: string;
+    expectedFormat?: string;
+    expectedTransports?: string[];
+}
+export interface APIClientEnvironmentTest {
+    name: string;
+    environment: EnvironmentConfig;
+    expectedBaseURL: string;
+    expectedTimeout: number;
+    expectedHeaders?: Record<string, string>;
+}
+export interface SecretsManagementTest {
+    name: string;
+    environment: EnvironmentConfig;
+    secrets: Record<string, string>;
+    expectedBehavior: 'store' | 'mock' | 'error';
+}
+export interface SecretsManager {
+    get: (key: string) => Promise<string | undefined>;
+    set: (key: string, value: string) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+}
+export interface MockEnvironment {
+    update: (updates: EnvironmentConfig) => void;
+    get: (key: string) => string | undefined;
+    set: (key: string, value: string) => void;
+    unset: (key: string) => void;
+    restore: () => void;
+    getAll: () => EnvironmentConfig;
+    clear: () => void;
+}
+export interface EnvironmentTransformationTestCase {
+    input: EnvironmentConfig;
+    expectedOutput: Record<string, unknown>;
+    description: string;
+}
+export interface UserInteraction {
+    keyboard: (keys: string) => Promise<void>;
+    tab?: () => Promise<void>;
+    click?: (element: HTMLElement) => Promise<void>;
+}
+export interface AccessibilityReport {
+    hasAccessibleName: boolean;
+    isVisible: boolean;
+    isFocusable: boolean;
+    hasProperRole: boolean;
+    hasKeyboardSupport: boolean;
+    ariaAttributes: Record<string, string>;
+    landmarks: number;
+    headingStructure: string[];
+}
+export interface MockNextNavigationOptions {
+    pathname?: string;
+    searchParams?: Record<string, string | string[]>;
+    push?: ReturnType<typeof Vitest.vi.fn>;
+    replace?: ReturnType<typeof Vitest.vi.fn>;
+    refresh?: ReturnType<typeof Vitest.vi.fn>;
+    back?: ReturnType<typeof Vitest.vi.fn>;
+    forward?: ReturnType<typeof Vitest.vi.fn>;
+}
+export interface SRTestOptions {
+    initialProps: Record<string, unknown>;
+    revalidate: number;
+    newProps: Record<string, unknown>;
+    waitTime?: number;
+}
+export interface ApiRouteTestScenario {
+    name: string;
+    request: Partial<MockNextApiRequest>;
+    expectedStatus: number;
+    expectedBody?: unknown;
+    expectedHeaders?: Record<string, string>;
+}
+export interface ApiMiddlewareTestScenario {
+    name: string;
+    request: Partial<MockNextApiRequest>;
+    shouldCallNext: boolean;
+    modifications?: {
+        request?: Partial<MockNextApiRequest>;
+        response?: Partial<MockNextApiResponse>;
+    };
+}
+export interface EventSequenceTracker {
+    record: (event: string) => void;
+    verify: () => void;
+    getRecorded: () => string[];
+    reset: () => void;
+}
+export interface ApiAuthScenario {
+    name: string;
+    headers?: Record<string, string>;
+    cookies?: Record<string, string>;
+    expectedStatus: number;
+    expectedMessage?: string;
+}
+export interface ApiRouteOptions {
+    method?: string;
+    url?: string;
+    headers?: Record<string, string | string[]>;
+    query?: Record<string, string | string[]>;
+    body?: unknown;
+    cookies?: Record<string, string>;
+}
+export interface ServerComponentTestScenario {
+    name: string;
+    props: Record<string, unknown>;
+    searchParams?: Record<string, string>;
+    params?: Record<string, string>;
+    expectedContent?: string | RegExp;
+}
+export interface MiddlewareMatcherConfig {
+    matcher: string | string[];
+}
+export interface MockNextNavigationResult {
+    navigation: {
+        push: ReturnType<typeof Vitest.vi.fn>;
+        replace: ReturnType<typeof Vitest.vi.fn>;
+        refresh: ReturnType<typeof Vitest.vi.fn>;
+        back: ReturnType<typeof Vitest.vi.fn>;
+        forward: ReturnType<typeof Vitest.vi.fn>;
+    };
+    restore: () => void;
+}
+export interface TestHarnessOptions<TOptions> {
+    create: (deps: Map<unknown, unknown>, opts: TOptions) => unknown;
+    dependencies?: Array<TestDependency>;
+}
+export interface TestHarnessResult<T> {
+    instance: T;
+    dependencies: Map<unknown, unknown>;
+    logger?: unknown;
+    getDependency: <U>(token: unknown) => U;
+}
+export interface ConsoleMockOptions {
+    suppressAll?: boolean;
+    suppress?: Array<'log' | 'error' | 'warn' | 'info' | 'debug'>;
+}
+export type ConsoleMethod = 'log' | 'error' | 'warn' | 'info' | 'debug';
+export interface HookErrorResult {
+    error?: {
+        message: string;
+    };
+}
+export interface ComponentWithLoading {
+    isLoading?: boolean;
+    [key: string]: unknown;
+}
+export interface ConditionalRenderingTest {
+    props: Record<string, unknown>;
+    shouldRender: string[];
+    shouldNotRender: string[];
+}
+export interface ProviderConfig {
+    Provider: React.ComponentType<{
+        children: React.ReactNode;
+        [key: string]: unknown;
+    }>;
+    props?: Record<string, unknown>;
+}
+export interface UserInteractionTest {
+    name: string;
+    action: (user: unknown) => Promise<void>;
+    expectation: () => void;
+}
+export interface ErrorBoundaryTest {
+    error: Error;
+    expectedMessage?: string;
+    shouldHaveReset?: boolean;
+}
+export interface ComponentTestSuiteResult {
+    testRendering: () => void;
+    testUserInteractions: (interactions: Array<UserInteractionTest>) => void;
+    testProps: (propVariations: Array<PropVariation>) => void;
+}
+export interface ResourceCleanupTest {
+    name: string;
+    create: () => unknown;
+    cleanup: (resource: unknown) => Promise<void> | void;
+    isCleanedUp: (resource: unknown) => boolean;
+}
+export interface DependencyInjectionContainer {
+    register: (token: unknown, factory: () => unknown, options: {
+        lifecycle: 'singleton' | 'transient' | 'scoped';
+        dependencies?: unknown[];
+    }) => void;
+    resolve: (token: unknown) => unknown;
+    dispose: () => Promise<void>;
+}
+export interface DependencyInjectionConfig {
+    token: unknown;
+    factory: () => unknown;
+    dependencies?: unknown[];
+    lifecycle: 'singleton' | 'transient' | 'scoped';
+    cleanup?: (instance: unknown) => void;
+}
+export interface AsyncLifecycleHook {
+    name: string;
+    method: string;
+    timeout?: number;
+    shouldReject?: boolean;
+    expectedError?: string | RegExp;
+}
+export interface LifecycleTestHarnessResult<T> {
+    instance: T;
+    getHooks: () => Array<LifecycleHookRecord>;
+    clearHooks: () => void;
+    getHooksByPhase: (phase: string) => Array<LifecycleHookRecord>;
+    getLastHook: () => LifecycleHookRecord | undefined;
+    expectHookCalled: (method: string) => void;
+    expectHookOrder: (expectedOrder: string[]) => void;
+}
+export interface GracefulShutdownOptions {
+    shutdownTimeout?: number;
+    signals?: globalThis.NodeJS.Signals[];
+    expectedCleanupActions?: string[];
+}
+export interface HookCleanupFunction {
+    unmount: () => void;
+}
+export interface MockIntersectionObserverEntry {
+    target: Element;
+    isIntersecting: boolean;
+    intersectionRatio: number;
+    boundingClientRect: DOMRect;
+}
+export type ConfigObject = Record<string, unknown>;
+export type ConfigLoader = (env: string) => unknown;
+export type EnvironmentTransformer = (env: EnvironmentConfig) => ConfigObject;
+export type KeyboardUserInteraction = Pick<UserInteraction, 'keyboard'>;
+export type FocusUserInteraction = Required<Pick<UserInteraction, 'keyboard' | 'tab'>>;
+export type SkipLinkUserInteraction = Required<Pick<UserInteraction, 'click' | 'tab'>>;
+export type AccessibilityAttributesMap = Record<string, string>;
+export type TestParameters = Record<string, unknown>;
+export type TestMatrixInputs<T extends Record<string, unknown[]>> = {
+    [K in keyof T]: T[K][];
+};
+export type TestMatrixCombination<T extends Record<string, unknown[]>> = {
+    [K in keyof T]: T[K][number];
+};
+export type PartialTestMatrixCombination<T extends Record<string, unknown[]>> = Partial<{
+    [K in keyof T]: T[K][number];
+}>;
+export type PropertyTestFunction<T> = (value: T) => boolean | Promise<boolean>;
+export type StateTransitionApplyFunction<TState, TAction> = (state: TState, action: TAction) => TState;
+export type CombinationTestFunction<T extends Record<string, unknown[]>> = (combination: TestCombination<T>) => void | Promise<void>;
+export type UnknownFunction = (...args: unknown[]) => unknown;
+export interface SpyTargetConfig {
+    obj: UnknownRecord;
+    method: string;
+    implementation?: UnknownFunction;
+}
+export type ModuleMockFactories = Record<string, () => UnknownRecord>;
+export interface TestCaseWithSetup<T> {
+    name: string;
+    args: unknown[];
+    expected: unknown;
+    setup?: (instance: T) => void;
+}
+export interface LifecycleHookTestConfig<T> {
+    name: string;
+    hook: keyof T;
+    expectedCalls?: number;
+    expectError?: boolean;
+}
+export interface ErrorHandlingScenario<T> {
+    method: keyof T;
+    args: unknown[];
+    expectedError: string | RegExp | typeof Error;
+    setup?: (instance: T) => void;
+}
+export type VoidFunction = () => void;
+export type ValueHandler<T> = (value: T) => void;
+export type ErrorHandler = (error: unknown) => void;
+export type DataHandler<T> = (data: T) => void;
+export type ValueGetter<T> = () => T;
+export type GenericArgsFunction<T> = (...args: unknown[]) => T;
+export type AsyncFunction<T> = () => Promise<T>;
+export interface OriginalConsole {
+    log: typeof globalThis.console.log;
+    error: typeof globalThis.console.error;
+    warn: typeof globalThis.console.warn;
+    info: typeof globalThis.console.info;
+    debug: typeof globalThis.console.debug;
+}
+export interface ElementInfo {
+    tagName: string;
+    id: string;
+    className: string;
+    textContent: string | null;
+    attributes: Record<string, string>;
+}
+export interface DebouncedFunction<T extends (...args: unknown[]) => unknown> extends Function {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+    flush: () => void;
+}
+export interface ThrottledFunction<T extends (...args: unknown[]) => unknown> extends Function {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+}
+export interface Stopwatch {
+    start(): void;
+    lap(): number;
+    stop(): number;
+    getLaps(): number[];
+    reset(): void;
+}
+export interface ControllerTestHarnessReturn<T> {
+    controller: T;
+    moduleRef: {
+        get: <U>(token: unknown) => U;
+    };
+    logger?: unknown;
+}
+export interface ServiceTestHarnessReturn<T> {
+    service: T;
+    dependencies: Map<unknown, unknown>;
+    logger?: unknown;
+    resetMocks: () => void;
+    expectCalled: (method: keyof T, times?: number) => void;
+    expectCalledWith: (method: keyof T, ...args: unknown[]) => void;
+}
+export interface DynamicModuleClass {
+    forRoot: (config: unknown) => Record<string, unknown>;
+}
+export interface DynamicModuleExpectations {
+    providers?: unknown[];
+    imports?: unknown[];
+    exports?: unknown[];
+}
+export interface NestJSTestSuiteSetupReturn {
+    module: unknown;
+    providers: Map<unknown, unknown>;
+}
+export interface ProviderInjectionTest {
+    token: unknown;
+    dependencies: unknown[];
+    testFn: (instance: unknown, deps: unknown[]) => void;
+}
+export interface WebSocketPingMessage {
+    type: 'ping';
+}
+export interface WebSocketPongMessage {
+    type: 'pong';
+}
+export interface WebSocketEchoMessage {
+    type: 'echo';
+    data: string;
+}
+export interface WebSocketTypedMessage {
+    type: string;
+    data: string;
+}
+export interface ImageLoaderInput {
+    src: string;
+    width: number;
+    quality?: number;
+}
+export interface UserFlowStep {
+    name: string;
+    interactions: InteractionSequence[];
+    assertions: () => void | Promise<void>;
+    navigation?: {
+        expectedUrl?: string;
+        waitForNavigation?: boolean;
+    };
+}
+export interface MockNextRequestCreatorParams {
+    url: string;
+    options?: {
+        method?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+        searchParams?: Record<string, string>;
+    };
+}
+export interface ProviderInjection {
+    token: unknown;
+    dependencies: unknown[];
+    testFn: (instance: unknown, deps: unknown[]) => void;
+}
+export interface CreateMockRedisClientMock {
+    set: Vitest.Mock;
+    get: Vitest.Mock;
+    del: Vitest.Mock;
+    keys: Vitest.Mock;
+    quit: Vitest.Mock;
+    on: Vitest.Mock;
+    multi: Vitest.Mock;
+    ping: Vitest.Mock;
+}