@plyaz/types 1.4.0 → 1.5.0

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.Mock;
+    mock: Vitest.MockInstance;
     /** Resolve the next pending promise with a value */
     resolve: (value: T) => void;
     /** Reject the next pending promise with an error */
@@ -561,11 +561,11 @@ export interface TestCleanup {
     clear: () => void;
 }
 export interface MockConsole {
-    log: Vitest.Mock;
-    error: Vitest.Mock;
-    warn: Vitest.Mock;
-    info: Vitest.Mock;
-    debug: Vitest.Mock;
+    log: Vitest.MockInstance;
+    error: Vitest.MockInstance;
+    warn: Vitest.MockInstance;
+    info: Vitest.MockInstance;
+    debug: Vitest.MockInstance;
     restore: () => void;
 }
 export interface MockEnv {
@@ -793,12 +793,14 @@ export interface ThrottleResult {
     called: boolean;
     args?: unknown[];
 }
-export interface AsyncScenario<T> {
+export interface AsyncScenario<T = void> {
     name: string;
     setup: () => Promise<void>;
     action: () => Promise<T>;
     verify: (result: T) => void | Promise<void>;
     cleanup?: () => Promise<void>;
+    /** Expected hooks */
+    expectedHooks: string[];
 }
 export interface WaitForChangeOptions<T> {
     timeout?: number;
@@ -1147,10 +1149,10 @@ export interface MockCallResult {
     error?: unknown;
 }
 export interface FileWatcher extends MockEventEmitter {
-    add: Vitest.Mock;
-    unwatch: Vitest.Mock;
-    close: Vitest.Mock;
-    getWatched: Vitest.Mock;
+    add: Vitest.MockInstance;
+    unwatch: Vitest.MockInstance;
+    close: Vitest.MockInstance;
+    getWatched: Vitest.MockInstance;
     simulateChange: (path: string) => void;
     simulateAdd: (path: string) => void;
     simulateUnlink: (path: string) => void;
@@ -1195,9 +1197,9 @@ export interface MockNextRequest {
         href: string;
     };
     cookies: {
-        get: Vitest.Mock;
-        set: Vitest.Mock;
-        delete: Vitest.Mock;
+        get: Vitest.MockInstance;
+        set: Vitest.MockInstance;
+        delete: Vitest.MockInstance;
     };
     geo: {
         city: string;
@@ -1209,24 +1211,24 @@ export interface MockNextRequest {
 }
 export interface MockNextResponse {
     cookies: {
-        set: Vitest.Mock;
-        delete: Vitest.Mock;
+        set: Vitest.MockInstance;
+        delete: Vitest.MockInstance;
     };
     headers: Headers;
     status: number;
-    redirect: Vitest.Mock;
-    rewrite: Vitest.Mock;
-    next: Vitest.Mock;
-    json: Vitest.Mock;
+    redirect: Vitest.MockInstance;
+    rewrite: Vitest.MockInstance;
+    next: Vitest.MockInstance;
+    json: Vitest.MockInstance;
 }
 export interface MockWebSocketServer extends MockEventEmitter {
     clients: Set<CreateMockWebSocketReturn>;
     port: number;
     host: string;
     maxClients: number;
-    handleUpgrade: Vitest.Mock;
-    shouldHandle: Vitest.Mock;
-    close: Vitest.Mock;
+    handleUpgrade: Vitest.MockInstance;
+    shouldHandle: Vitest.MockInstance;
+    close: Vitest.MockInstance;
     addClient: (client: CreateMockWebSocketReturn) => void;
     removeClient: (client: CreateMockWebSocketReturn) => void;
     simulateConnection: (clientId?: string) => CreateMockWebSocketReturn;
@@ -1959,12 +1961,1200 @@ export interface ProviderInjection {
     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;
+    set: Vitest.MockInstance;
+    get: Vitest.MockInstance;
+    del: Vitest.MockInstance;
+    keys: Vitest.MockInstance;
+    quit: Vitest.MockInstance;
+    on: Vitest.MockInstance;
+    multi: Vitest.MockInstance;
+    ping: Vitest.MockInstance;
+}
+/**
+ * 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
+ */
+export interface TrackedSpy extends SpyInstance {
+    /** Get call count */
+    getCallCount: () => number;
+    /** Get call history */
+    getCallHistory: () => Array<{
+        args: unknown[];
+        result?: unknown;
+        error?: unknown;
+    }>;
+}
+/**
+ * Spy map type
+ * @typeParam T - Type to map to spies
+ */
+export type SpyMap<T> = {
+    [K in keyof T]: SpyInstance;
+};
+/**
+ * Tracked data interface
+ * @interface TrackedData
+ * @typeParam T - Type of tracked data
+ */
+export interface TrackedData<T> {
+    /** Data being tracked */
+    data: T;
+    /** Access history */
+    accesses: Array<{
+        property: string | symbol;
+        timestamp: number;
+    }>;
+}
+/**
+ * Access information
+ * @interface AccessInfo
+ */
+export interface AccessInfo {
+    /** Property being accessed */
+    property: string | symbol;
+    /** Access timestamp */
+    timestamp: number;
+    /** Access count */
+    count: number;
+}
+/**
+ * Worker-like interface for various worker types
+ * @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;
+}
+/**
+ * Worker pool interface
+ * @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;
+        idleWorkers: number;
+        tasksCompleted: number;
+        tasksFailed: number;
+        tasksRemaining: number;
+        workerStats: Array<{
+            id: number;
+            busy: boolean;
+            taskCount: number;
+        }>;
+    };
+}
+/**
+ * Worker metrics interface
+ * @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;
+}
+/**
+ * Worker test harness interface
+ * @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;
+        avgExecutionTime: number;
+        avgThroughput: number;
+        errorCount: number;
+        workerMetrics: WorkerMetrics[];
+    };
+}
+/**
+ * Worker spy interface
+ * @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;
+}
+/**
+ * Performance profiling options
+ * @interface ProfileOptions
+ */
+export interface ProfileOptions {
+    /** Sample interval in milliseconds */
+    sampleInterval?: number;
+    /** Include memory profiling */
+    includeMemory?: boolean;
+    /** Include CPU profiling */
+    includeCPU?: boolean;
+}
+/**
+ * Performance profile result
+ * @interface ProfileResult
+ * @typeParam T - Type of profiled operation result
+ */
+export interface ProfileResult<T> {
+    /** Operation result */
+    result: T;
+    /** CPU profile data */
+    cpuProfile?: {
+        /** Profile samples */
+        samples: number[];
+        /** Sample timestamps */
+        timestamps: number[];
+    };
+    /** Memory profile data */
+    memoryProfile?: {
+        /** Memory usage samples */
+        samples: number[];
+        /** Memory timestamps */
+        timestamps: number[];
+    };
+}
+/**
+ * Stress testing options
+ * @interface StressTestOptions
+ */
+export interface StressTestOptions {
+    /** Test duration in milliseconds */
+    duration?: number;
+    /** Number of concurrent operations */
+    concurrency?: number;
+    /** Ramp-up time */
+    rampUp?: number;
+    /** Operation rate limit */
+    rate?: number;
+}
+/**
+ * Stress test result
+ * @interface StressTestResult
+ */
+export interface StressTestResult {
+    /** Total operations performed */
+    totalOperations: number;
+    /** Successful operations */
+    successfulOperations: number;
+    /** Failed operations */
+    failedOperations: number;
+    /** Average response time */
+    averageResponseTime: number;
+    /** Error details */
+    errors: Error[];
+}
+/**
+ * Throughput test result
+ * @interface ThroughputResult
+ */
+export interface ThroughputResult {
+    /** Operations completed */
+    operationsCompleted: number;
+    /** Test duration */
+    duration: number;
+    /** Throughput rate */
+    throughput: number;
+    /** Peak throughput */
+    peakThroughput: number;
+}
+/**
+ * Performance monitoring options
+ * @interface MonitorOptions
+ */
+export interface MonitorOptions {
+    /** Monitoring interval */
+    interval?: number;
+    /** Metrics to collect */
+    metrics?: Array<'cpu' | 'memory' | 'time'>;
+}
+/**
+ * Performance monitor interface
+ * @interface PerformanceMonitor
+ */
+export interface PerformanceMonitor {
+    /** Start monitoring */
+    start: () => void;
+    /** Stop monitoring */
+    stop: () => void;
+    /** Get collected metrics */
+    getMetrics: () => {
+        /** CPU metrics */
+        cpu: number[];
+        /** Memory metrics */
+        memory: number[];
+        /** Time metrics */
+        time: number[];
+    };
+}
+/**
+ * Memory leak testing options
+ * @interface LeakOptions
+ */
+export interface LeakOptions {
+    /** Number of test iterations */
+    iterations?: number;
+    /** Memory threshold */
+    threshold?: number;
+    /** Run GC between runs */
+    gcBetweenRuns?: boolean;
+}
+/**
+ * Memory leak test result
+ * @interface LeakResult
+ */
+export interface LeakResult {
+    /** Whether leak was detected */
+    hasLeak: boolean;
+    /** Memory growth amount */
+    memoryGrowth: number;
+    /** Memory measurements */
+    measurements: Array<{
+        /** Iteration number */
+        iteration: number;
+        /** Memory usage */
+        memory: number;
+        /** Timestamp */
+        timestamp: number;
+    }>;
+}
+/**
+ * Hook testing scenario
+ * @interface HookScenario
+ * @typeParam T - Type of hook result
+ */
+export interface HookScenario<T> {
+    /** Scenario name */
+    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;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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[];
+}
+/**
+ * Accessibility violation
+ * @interface A11yViolation
+ */
+export interface A11yViolation {
+    /** Rule ID */
+    id: string;
+    /** Violation description */
+    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;
+    }>;
+}
+/**
+ * Accessibility test pass
+ * @interface A11yPass
+ */
+export interface A11yPass {
+    /** Rule ID */
+    id: string;
+    /** Rule description */
+    description: string;
+    /** Passed nodes */
+    nodes: Array<{
+        /** Element HTML */
+        html: string;
+        /** Element selector */
+        target: string[];
+    }>;
+}
+/**
+ * Incomplete accessibility test
+ * @interface A11yIncomplete
+ */
+export interface A11yIncomplete {
+    /** Rule ID */
+    id: string;
+    /** Rule description */
+    description: string;
+    /** Incomplete nodes */
+    nodes: Array<{
+        /** Element HTML */
+        html: string;
+        /** Element selector */
+        target: string[];
+    }>;
+}
+/**
+ * Accessibility test report
+ * @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;
+}
+/**
+ * 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'>;
+}
+/**
+ * Color contrast test result
+ * @interface ContrastResult
+ */
+export interface ContrastResult {
+    /** Foreground color */
+    foreground: string;
+    /** Background color */
+    background: string;
+    /** Contrast ratio */
+    ratio: number;
+    /** WCAG AA compliance */
+    AA: boolean;
+    /** WCAG AAA compliance */
+    AAA: boolean;
+}
+/**
+ * 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;
+}
+/**
+ * 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>;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+    };
+}
+/**
+ * User interaction record
+ * @interface Interaction
+ */
+export interface Interaction {
+    /** Interaction type */
+    type: 'click' | 'type' | 'hover' | 'focus' | 'blur';
+    /** Target element */
+    element: Element;
+    /** Interaction data */
+    data?: unknown;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Swipe gesture parameters
+ * @interface SwipeGestureParams
+ */
+export interface SwipeGestureParams {
+    /** Start coordinates */
+    start: {
+        x: number;
+        y: number;
+    };
+    /** End coordinates */
+    end: {
+        x: number;
+        y: number;
+    };
+    /** Gesture duration */
+    duration?: number;
+    /** Number of touch points */
+    touches?: number;
+}
+/**
+ * Pinch gesture parameters
+ * @interface PinchGestureParams
+ */
+export interface PinchGestureParams {
+    /** Center coordinates */
+    center: {
+        x: number;
+        y: number;
+    };
+    /** Scale factor */
+    scale: number;
+    /** Gesture duration */
+    duration?: number;
+    /** Rotation angle */
+    rotation?: number;
+}
+/**
+ * Animation frame data
+ * @interface Frame
+ */
+export interface Frame {
+    /** Frame timestamp */
+    timestamp: number;
+    /** Frame progress */
+    progress: number;
+    /** Frame values */
+    values: Record<string, number>;
+}
+/**
+ * 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;
+}
+/**
+ * RequestAnimationFrame options
+ * @interface RAFOptions
+ */
+export interface RAFOptions {
+    /** Auto start */
+    autoStart?: boolean;
+    /** Frame limit */
+    frameLimit?: number;
+    /** FPS target */
+    targetFPS?: 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;
+}
+/**
+ * Interval handle
+ * @interface IntervalHandle
+ */
+export interface IntervalHandle {
+    /** Interval ID */
+    id: number;
+    /** Clear interval */
+    clear: () => void;
+    /** Check if active */
+    isActive: () => boolean;
+}
+/**
+ * Schedule handle
+ * @interface ScheduleHandle
+ */
+export interface ScheduleHandle {
+    /** Timeout ID */
+    id: number;
+    /** Cancel schedule */
+    cancel: () => void;
+    /** Check if pending */
+    isPending: () => boolean;
+}
+/**
+ * Timer interface
+ * @interface Timer
+ */
+export interface Timer {
+    /** Start time */
+    startTime: number;
+    /** End time */
+    endTime?: number;
+    /** Elapsed time */
+    elapsed: number;
+    /** Timer label */
+    label?: string;
+}
+/**
+ * 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;
+}
+/**
+ * History entry
+ * @interface HistoryEntry
+ */
+export interface HistoryEntry {
+    /** Entry URL */
+    url: string;
+    /** Entry state */
+    state?: unknown;
+    /** Entry title */
+    title?: string;
+    /** Entry timestamp */
+    timestamp: number;
+}
+/**
+ * Mock history object
+ * @interface MockHistory
+ */
+export interface MockHistory {
+    /** History entries */
+    entries: HistoryEntry[];
+    /** Current index */
+    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;
+}
+/**
+ * Mock location object
+ * @interface MockLocation
+ */
+export interface MockLocation {
+    /** Current pathname */
+    pathname: string;
+    /** Current search */
+    search: string;
+    /** Current hash */
+    hash: string;
+    /** Current state */
+    state?: unknown;
+    /** Location key */
+    key: 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * Navigation options
+ * @interface NavOptions
+ */
+export interface NavOptions {
+    /** Replace current entry */
+    replace?: boolean;
+    /** Navigation state */
+    state?: unknown;
+    /** Prevent default */
+    preventDefault?: boolean;
+}
+/**
+ * Next.js testing options
+ * @interface NextOptions
+ */
+export interface NextOptions {
+    /** Router configuration */
+    router?: Partial<unknown>;
+    /** Current pathname */
+    pathname?: string;
+    /** Search parameters */
+    searchParams?: Record<string, string>;
+    /** Request cookies */
+    cookies?: Record<string, string>;
+}
+/**
+ * Next.js test context
+ * @interface NextTestContext
+ */
+export interface NextTestContext {
+    /** Mock router instance */
+    router: unknown;
+    /** Navigation mock */
+    navigation: unknown;
+    /** Request mock */
+    req: unknown;
+    /** Response mock */
+    res: unknown;
+    /** Reset function */
+    reset: () => void;
+}
+/**
+ * Server-side props context for testing
+ * @interface SSPContext
+ */
+export interface SSPContext {
+    /** Test scenario name */
+    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 */
+    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>;
+}
+/**
+ * Lifecycle testing scenario
+ * @interface LifecycleScenario
+ */
+export interface LifecycleScenario {
+    /** Scenario name */
+    name: string;
+    /** Action to perform */
+    action: () => void | Promise<void>;
+    /** Expected state after action */
+    expectedState?: Record<string, unknown>;
+    /** Expected events */
+    expectedEvents?: string[];
+}
+/**
+ * Lifecycle event tracker
+ * @interface LifecycleTracker
+ */
+export interface LifecycleTracker {
+    /** Recorded events */
+    events: Array<{
+        type: string;
+        timestamp: number;
+        data?: unknown;
+    }>;
+    /** Clear all events */
+    clear: () => void;
+    /** Get all events */
+    getEvents: () => Array<{
+        type: string;
+        timestamp: number;
+        data?: unknown;
+    }>;
+    /** Get events by type */
+    getEventsByType: (type: string) => Array<{
+        type: string;
+        timestamp: number;
+        data?: unknown;
+    }>;
+}
+/**
+ * Lifecycle event
+ * @interface LifecycleEvent
+ */
+export interface LifecycleEvent {
+    /** Event type */
+    type: string;
+    /** Event data */
+    data?: unknown;
+}
+/**
+ * Cleanup operation result
+ * @interface CleanupResult
+ */
+export interface CleanupResult {
+    /** Whether cleanup was successful */
+    cleanedUp: boolean;
+    /** Cleaned up resources */
+    resources: string[];
+    /** Cleanup errors */
+    errors: Error[];
+}
+/**
+ * Lifecycle performance metrics
+ * @interface LifecycleMetrics
+ */
+export interface LifecycleMetrics {
+    /** Mount time */
+    mountTime: number;
+    /** Update time */
+    updateTime: number;
+    /** Unmount time */
+    unmountTime: number;
+}
+/**
+ * File snapshot for testing
+ * @interface FileSnapshot
+ */
+export interface FileSnapshot {
+    /** File path */
+    path: string;
+    /** File size */
+    size: number;
+    /** Modification time */
+    mtime: Date;
+    /** File content */
+    content: string;
+    /** Content hash */
+    hash: string;
+}
+/**
+ * Environment configuration
+ * @interface EnvConfig
+ */
+export interface EnvConfig {
+    /** Base directory */
+    baseDir?: string;
+    /** Environment file path */
+    envFile?: string;
+    /** Override existing values */
+    override?: boolean;
+    /** Default values */
+    defaults?: Record<string, string>;
+}
+/**
+ * Test environment interface
+ * @interface TestEnvironment
+ */
+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;
+}
+/**
+ * Environment mock interface
+ * @interface EnvMock
+ */
+export interface EnvMock {
+    /** Restore original environment */
+    restore: () => void;
+    /** Update environment variables */
+    update: (vars: Record<string, string>) => void;
+    /** Clear environment variables */
+    clear: () => void;
+}
+/**
+ * Environment snapshot
+ * @interface EnvSnapshot
+ */
+export interface EnvSnapshot {
+    /** Environment variables */
+    variables: Record<string, string | undefined>;
+    /** Snapshot timestamp */
+    timestamp: number;
+}
+/**
+ * System signal type
+ * @type Signal
+ */
+export type Signal = 'SIGTERM' | 'SIGINT' | 'SIGHUP' | 'SIGUSR1' | 'SIGUSR2';
+/**
+ * Signal handler function
+ * @type SignalHandler
+ */
+export type SignalHandler = (signal: Signal) => void | Promise<void>;
+/**
+ * Component type for lifecycle testing
+ * @type ComponentType
+ * @typeParam P - Props type
+ */
+export type ComponentType<P = Record<string, unknown>> = new (props: P) => React.Component<P>;
+/**
+ * Next.js Get Server-Side Props function
+ * @type GSSP
+ * @typeParam T - Props type
+ */
+export type GSSP<T = unknown> = (context: T) => Promise<T>;
+/**
+ * Next.js Get Static Props function
+ * @type GSP
+ * @typeParam T - Props type
+ */
+export type GSP<T = unknown> = (context: T) => Promise<T>;
+/**
+ * Next.js API handler function
+ * @type APIHandler
+ */
+export type APIHandler = (req: unknown, res: unknown) => Promise<void> | void;
+/**
+ * Touch gesture type
+ * @type TouchGesture
+ */
+export type TouchGesture = 'tap' | 'swipe' | 'pinch' | 'rotate' | 'longPress';
+/**
+ * File watch callback function
+ * @type WatchCallback
+ */
+export type WatchCallback = (event: string, filename: string | null) => void;
+/**
+ * Pipeline result interface
+ * @interface PipelineResult
+ */
+export interface PipelineResult {
+    /** Output buffer */
+    output: globalThis.Buffer;
+    /** Errors array */
+    errors: Error[];
+    /** Duration in milliseconds */
+    duration: number;
+}
+/**
+ * Module mocks interface
+ * @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[];
+}
+/**
+ * Async hook interface
+ * @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;
 }