/**
 * Data Analysis Utilities
 *
 * General-purpose utilities for scientific data formatting,
 * cycle detection, peak detection, and data validation.
 */
type SIPrefix = 'p' | 'n' | 'µ' | 'm' | '' | 'k' | 'M' | 'G';
export interface PrefixInfo {
    symbol: SIPrefix;
    factor: number;
}
/**
 * Find the best SI prefix for a value
 */
export declare function getBestPrefix(value: number): PrefixInfo;
/**
 * Format a value with automatic SI prefix
 *
 * @example
 * formatWithPrefix(0.000001, 'A') // "1.00 µA"
 * formatWithPrefix(0.5, 'V')      // "500 mV"
 * formatWithPrefix(1500, 'm')     // "1.50 km"
 */
export declare function formatWithPrefix(value: number, unit: string, decimals?: number): string;
/**
 * Format a numeric value with specified decimals
 * Automatically switches to scientific notation for very large/small values
 */
export declare function formatValue(value: number, decimals?: number): string;
/**
 * Format value in scientific notation
 */
export declare function formatScientific(value: number, decimals?: number): string;
export interface CycleInfo {
    /** Cycle number (1-indexed) */
    number: number;
    /** Start index in data array */
    startIndex: number;
    /** End index in data array */
    endIndex: number;
    /** Direction at start: 1 = forward, -1 = reverse */
    direction: 1 | -1;
}
/**
 * Detect cycles in oscillating data
 *
 * A cycle is complete when the signal returns to its starting value
 * after going through both sweep directions. Useful for:
 * - Cyclic voltammetry data
 * - Periodic signals
 * - Oscillation analysis
 *
 * @param signal - The signal data (e.g., potential, position, etc.)
 * @param tolerance - How close to starting value to consider a cycle complete
 */
export declare function detectCycles(signal: Float32Array | Float64Array | number[], tolerance?: number): CycleInfo[];
/**
 * Generate distinct colors for cycles/series
 *
 * Uses HSL color space to generate evenly distributed hues
 */
export declare function generateCycleColors(count: number): string[];
export interface Peak {
    /** Index in data array */
    index: number;
    /** X value at peak */
    x: number;
    /** Y value at peak */
    y: number;
    /** Peak type */
    type: 'max' | 'min';
    /** Prominence of the peak */
    prominence: number;
}
/**
 * Detect peaks (local maxima and minima) in data
 *
 * Uses simple local extrema detection with optional prominence filtering.
 * Useful for:
 * - Signal peak detection
 * - Finding local maxima/minima
 * - Feature extraction
 *
 * @param x - X values (independent variable)
 * @param y - Y values (dependent variable)
 * @param options - Detection options
 */
export declare function detectPeaks(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[], options?: {
    /** Minimum prominence to be considered a peak */
    minProminence?: number;
    /** Only return 'max' or 'min' peaks */
    type?: 'max' | 'min' | 'both';
}): Peak[];
export interface ValidationResult {
    /** Whether all data is valid */
    valid: boolean;
    /** Number of invalid values (NaN, Infinity, etc.) */
    invalidCount: number;
    /** Index of first invalid value (-1 if all valid) */
    firstInvalidIndex: number;
}
/**
 * Validate that data contains only finite numbers
 *
 * Checks for NaN, Infinity, and -Infinity values.
 * Useful for data quality checks before rendering.
 */
export declare function validateData(data: Float32Array | Float64Array | number[]): ValidationResult;
export interface DataStats {
    min: number;
    max: number;
    mean: number;
    stdDev: number;
    count: number;
}
/**
 * Calculate basic statistics for a dataset
 */
export declare function calculateStats(data: Float32Array | Float64Array | number[]): DataStats;
/**
 * Apply moving average smoothing to data
 *
 * @param data - Input data array
 * @param windowSize - Number of points to average (must be odd)
 */
export declare function movingAverage(data: Float32Array | Float64Array | number[], windowSize: number): Float32Array;
/**
 * Downsample data using LTTB (Largest Triangle Three Buckets) algorithm
 *
 * Preserves visual characteristics while reducing point count.
 * Ideal for rendering large datasets efficiently.
 *
 * @param x - X values
 * @param y - Y values
 * @param targetPoints - Desired number of output points
 */
export declare function downsampleLTTB(x: Float32Array | Float64Array, y: Float32Array | Float64Array, targetPoints: number): {
    x: Float32Array;
    y: Float32Array;
};
/**
 * Subtract a linear baseline from data
 *
 * @param x - X data
 * @param y - Y data
 * @param x1 - Start of baseline segment
 * @param x2 - End of baseline segment
 */
export declare function subtractBaseline(x: Float32Array | number[], y: Float32Array | number[], x1: number, x2: number): Float32Array;
export {};