/**
 * Fast Fourier Transform (FFT) Implementation
 *
 * Provides:
 * - FFT for spectral analysis
 * - Inverse FFT
 * - Power spectrum
 * - Frequency bins calculation
 */
/** Complex number representation */
export interface Complex {
    re: number;
    im: number;
}
/** FFT Result */
export interface FFTResult {
    /** Frequency bins in Hz (if sample rate provided) or normalized */
    frequency: Float32Array;
    /** Magnitude spectrum */
    magnitude: Float32Array;
    /** Phase spectrum in radians */
    phase: Float32Array;
    /** Full complex spectrum as Complex[] array */
    complex: Complex[];
    /** Real part of full spectrum as Float32Array */
    real: Float32Array;
    /** Imaginary part of full spectrum as Float32Array */
    imag: Float32Array;
}
/** Complex FFT Result - full spectrum with separate real/imag arrays */
export interface ComplexFFTResult {
    /** Real part of spectrum */
    real: Float32Array;
    /** Imaginary part of spectrum */
    imag: Float32Array;
    /** Frequency bins in Hz (if sample rate provided) */
    frequency: Float32Array;
    /** Magnitude spectrum (sqrt(real² + imag²)) */
    magnitude: Float32Array;
    /** Phase spectrum in radians (atan2(imag, real)) */
    phase: Float32Array;
    /** Original spectrum length (power of 2) */
    length: number;
    /** Nyquist index (length / 2) */
    nyquist: number;
}
/** Power spectrum result */
export interface PowerSpectrumResult {
    /** Frequency bins */
    frequency: Float32Array;
    /** Power values (magnitude squared) */
    power: Float32Array;
    /** Power in dB */
    powerDb: Float32Array;
}
/**
 * Compute FFT using Cooley-Tukey algorithm
 * Input length must be a power of 2
 */
export declare function fft(input: Float32Array | Float64Array | number[]): Complex[];
/**
 * Compute inverse FFT
 */
export declare function ifft(spectrum: Complex[]): Float32Array;
/**
 * Find next power of 2
 */
export declare function nextPowerOf2(n: number): number;
/**
 * Compute full FFT analysis with frequencies and magnitudes
 */
export declare function analyzeSpectrum(data: Float32Array | Float64Array | number[], sampleRate?: number): FFTResult;
/**
 * Compute power spectrum
 */
export declare function powerSpectrum(data: Float32Array | Float64Array | number[], sampleRate?: number): PowerSpectrumResult;
/**
 * Find dominant frequency in signal
 */
export declare function dominantFrequency(data: Float32Array | Float64Array | number[], sampleRate?: number, minFrequency?: number): {
    frequency: number;
    magnitude: number;
};
/**
 * Apply Hanning window to data
 */
export declare function hanningWindow(data: Float32Array | Float64Array): Float32Array;
/**
 * Apply Hamming window to data
 */
export declare function hammingWindow(data: Float32Array | Float64Array): Float32Array;
/**
 * Apply Blackman window to data
 */
export declare function blackmanWindow(data: Float32Array | Float64Array): Float32Array;
/**
 * Compute full complex FFT analysis with separate real and imaginary arrays
 * This is useful when you need direct access to real/imag components
 */
export declare function analyzeComplexSpectrum(data: Float32Array | Float64Array | number[], sampleRate?: number): ComplexFFTResult;
/**
 * Compute FFT from complex input (real + imaginary arrays)
 * Useful for processing complex signals or chaining FFT operations
 */
export declare function fftFromComplexInput(real: Float32Array | Float64Array | number[], imag: Float32Array | Float64Array | number[]): ComplexFFTResult;
/**
 * Convert Complex[] array to separate real and imaginary Float32Arrays
 */
export declare function complexToArrays(complex: Complex[]): {
    real: Float32Array;
    imag: Float32Array;
};
/**
 * Convert separate real and imaginary arrays to Complex[] array
 */
export declare function arraysToComplex(real: Float32Array | Float64Array | number[], imag: Float32Array | Float64Array | number[]): Complex[];
/**
 * Compute inverse FFT from separate real and imaginary arrays
 * Returns the real part of the inverse transform
 */
export declare function ifftFromArrays(real: Float32Array | Float64Array | number[], imag: Float32Array | Float64Array | number[]): Float32Array;
/**
 * Compute inverse FFT returning complex result (both real and imaginary parts)
 */
export declare function ifftComplex(spectrum: Complex[]): {
    real: Float32Array;
    imag: Float32Array;
};
/**
 * Get only positive frequencies (up to Nyquist) from complex spectrum
 */
export declare function getPositiveFrequencies(result: ComplexFFTResult): {
    real: Float32Array;
    imag: Float32Array;
    frequency: Float32Array;
    magnitude: Float32Array;
    phase: Float32Array;
};