/**
 * Velo Plot - Testing Utilities
 *
 * Provides utilities for testing chart applications:
 * - Mock data generators
 * - Chart test harness
 * - Snapshot helpers
 * - Performance benchmarks
 *
 * @module testing
 */
export interface MockChartOptions {
    /** Canvas width (default: 800) */
    width?: number;
    /** Canvas height (default: 600) */
    height?: number;
    /** Device pixel ratio (default: 1) */
    devicePixelRatio?: number;
    /** Theme (default: 'dark') */
    theme?: string;
    /** Enable WebGL mock (default: true) */
    mockWebGL?: boolean;
}
export interface WaveformOptions {
    /** Number of points (default: 1000) */
    pointCount?: number;
    /** Amplitude (default: 1) */
    amplitude?: number;
    /** Frequency in Hz (default: 1) */
    frequency?: number;
    /** Phase offset in radians (default: 0) */
    phase?: number;
    /** Noise level (0-1, default: 0) */
    noise?: number;
    /** X start value (default: 0) */
    xStart?: number;
    /** X end value (default: 10) */
    xEnd?: number;
    /** DC offset (default: 0) */
    offset?: number;
}
export interface RandomDataOptions {
    /** Number of points (default: 1000) */
    pointCount?: number;
    /** X range [min, max] (default: [0, 100]) */
    xRange?: [number, number];
    /** Y range [min, max] (default: [-1, 1]) */
    yRange?: [number, number];
    /** Sort by X value (default: true) */
    sorted?: boolean;
    /** Seed for reproducible random (optional) */
    seed?: number;
}
export interface BenchmarkResult {
    /** Average frames per second */
    avgFps: number;
    /** Minimum FPS recorded */
    minFps: number;
    /** Maximum FPS recorded */
    maxFps: number;
    /** Average frame time in ms */
    avgFrameTime: number;
    /** Total frames rendered */
    frameCount: number;
    /** Test duration in ms */
    duration: number;
    /** Points per frame */
    pointsRendered: number;
    /** Points per second throughput */
    throughput: number;
    /** Render-only throughput (1000 / avgFrameTime); can exceed wall FPS */
    renderFps?: number;
}
export interface BenchmarkOptions {
    /** Duration of benchmark in ms (default: 5000) */
    duration?: number;
    /** Warmup duration in ms (default: 1000) */
    warmup?: number;
    /** Target FPS for assertions (default: 55) */
    targetFps?: number;
    /** Enable console output (default: false) */
    verbose?: boolean;
}
export interface SnapshotOptions {
    /** Output format: 'json' | 'png' | 'canvas' (default: 'json') */
    format?: 'json' | 'png' | 'canvas';
    /** Include data in snapshot (default: false for performance) */
    includeData?: boolean;
    /** Include styles in snapshot (default: true) */
    includeStyles?: boolean;
}
export interface ChartSnapshot {
    /** Snapshot timestamp */
    timestamp: number;
    /** Chart configuration */
    config: Record<string, unknown>;
    /** Series metadata (without data by default) */
    series: {
        id: string;
        type: string;
        pointCount: number;
        style?: Record<string, unknown>;
    }[];
    /** View bounds */
    bounds: {
        xMin: number;
        xMax: number;
        yMin: number;
        yMax: number;
    };
    /** Canvas data URL (if format is 'png') */
    image?: string;
}
/**
 * Generate a sine wave
 */
export declare function generateSineWave(options?: WaveformOptions): {
    x: Float32Array;
    y: Float32Array;
};
/**
 * Generate a square wave
 */
export declare function generateSquareWave(options?: WaveformOptions): {
    x: Float32Array;
    y: Float32Array;
};
/**
 * Generate a sawtooth wave
 */
export declare function generateSawtoothWave(options?: WaveformOptions): {
    x: Float32Array;
    y: Float32Array;
};
/**
 * Generate a triangle wave
 */
export declare function generateTriangleWave(options?: WaveformOptions): {
    x: Float32Array;
    y: Float32Array;
};
/**
 * Generate random data points
 */
export declare function generateRandomData(options?: RandomDataOptions): {
    x: Float32Array;
    y: Float32Array;
};
/**
 * Generate a cyclic voltammogram (CV) mock data
 */
export declare function generateCVData(options?: {
    pointCount?: number;
    vMin?: number;
    vMax?: number;
    cycles?: number;
    peakCurrent?: number;
    noise?: number;
}): {
    x: Float32Array;
    y: Float32Array;
};
/**
 * Generate electrochemical impedance spectroscopy (EIS) Nyquist data
 */
export declare function generateNyquistData(options?: {
    pointCount?: number;
    rSolution?: number;
    rCharge?: number;
    frequency?: [number, number];
}): {
    x: Float32Array;
    y: Float32Array;
};
/**
 * Benchmark chart rendering performance
 */
export declare function benchmarkRender(chart: {
    render: () => void;
    getAllSeries: () => {
        getPointCount: () => number;
    }[];
}, options?: BenchmarkOptions): Promise<BenchmarkResult>;
/**
 * Create a snapshot of chart state for testing
 */
export declare function createSnapshot(chart: {
    getViewBounds: () => {
        xMin: number;
        xMax: number;
        yMin: number;
        yMax: number;
    };
    getAllSeries: () => {
        getId: () => string;
        getType: () => string;
        getPointCount: () => number;
        getStyle: () => Record<string, unknown>;
    }[];
    exportImage?: () => string;
}, options?: SnapshotOptions): ChartSnapshot;
/**
 * Compare two snapshots for equality
 */
export declare function compareSnapshots(a: ChartSnapshot, b: ChartSnapshot, tolerance?: number): {
    equal: boolean;
    differences: string[];
};
/**
 * Assert that a benchmark meets performance requirements
 */
export declare function assertPerformance(result: BenchmarkResult, requirements: {
    minFps?: number;
    maxFrameTime?: number;
    minThroughput?: number;
}): {
    passed: boolean;
    failures: string[];
};
/**
 * Wait for a number of animation frames
 */
export declare function waitForFrames(count?: number): Promise<void>;
/**
 * Wait for a specified duration
 */
export declare function waitFor(ms: number): Promise<void>;
export { benchmarkCanvasGrid, benchmarkWebGLGrid, compareGridBackends, countGridVertices, type GridBenchmarkResult, type GridCompareResult, } from './gridSpikeBenchmark';
export { getBaseline, compareScenarioToBaseline, buildStage1Report, effectiveBenchmarkFps, HEADLESS_LOW_FRAME_THRESHOLD, SMOKE_FLOORS, type Stage1ScenarioResult, type Stage1BrowserReport, } from './stage1BrowserBench';
export { evaluateRendererCompare, type RendererCompareResult, } from './rendererBenchmark';