/**
 * Harmonic Analysis Module
 * Implements Harmonic Product Spectrum (HPS) and harmonic matching algorithms
 */
/**
 * Harmonic analysis configuration
 */
export interface HarmonicAnalysisConfig {
    sampleRate?: number;
    fftSize?: number;
    windowType?: 'hann' | 'hamming' | 'blackman' | 'rectangular';
    maxHarmonics?: number;
    harmonicTolerance?: number;
    minHarmonicStrength?: number;
    useHPS?: boolean;
    hpsDecimation?: number;
}
/**
 * Harmonic analysis result
 */
export interface HarmonicResult {
    fundamental: number;
    confidence: number;
    harmonics: Array<{
        frequency: number;
        amplitude: number;
        harmonicNumber: number;
        strength: number;
    }>;
    harmonicity: number;
    spectralCentroid: number;
    spectralRolloff: number;
}
/**
 * Harmonic Product Spectrum (HPS) analyzer
 */
export declare class HarmonicAnalyzer {
    private config;
    private fft;
    private window;
    constructor(config?: HarmonicAnalysisConfig);
    /**
     * Analyze harmonics in a signal
     */
    analyzeHarmonics(signal: Float32Array): HarmonicResult | null;
    /**
     * Find fundamental frequency using Harmonic Product Spectrum
     */
    private findFundamentalHPS;
    /**
     * Compute Harmonic Product Spectrum
     */
    private computeHPS;
    /**
     * Find peak in HPS
     */
    private findPeakInHPS;
    /**
     * Find fundamental using spectral analysis
     */
    private findFundamentalSpectral;
    /**
     * Find spectral peaks
     */
    private findSpectralPeaks;
    /**
     * Check if bin is a local maximum
     */
    private isLocalMaximum;
    /**
     * Find fundamental from spectral peaks
     */
    private findFundamentalFromPeaks;
    /**
     * Count harmonics of a fundamental frequency
     */
    private countHarmonics;
    /**
     * Find harmonics of a fundamental frequency
     */
    private findHarmonics;
    /**
     * Calculate harmonicity (ratio of harmonic to inharmonic energy)
     */
    private calculateHarmonicity;
    /**
     * Update configuration
     */
    updateConfig(config: Partial<HarmonicAnalysisConfig>): void;
    /**
     * Calculate spectral centroid
     */
    private calculateSpectralCentroid;
    /**
     * Calculate spectral rolloff
     */
    private calculateSpectralRolloff;
    /**
     * Get current configuration
     */
    getConfig(): Readonly<Required<HarmonicAnalysisConfig>>;
}
/**
 * Harmonic matching utilities
 */
export declare const HarmonicMatching: {
    /**
     * Match harmonics to a fundamental frequency
     */
    matchHarmonics(peaks: Array<{
        frequency: number;
        strength: number;
    }>, fundamental: number, tolerance?: number): Array<{
        frequency: number;
        strength: number;
        harmonicNumber: number;
    }>;
    /**
     * Find best fundamental from harmonic matches
     */
    findBestFundamental(peaks: Array<{
        frequency: number;
        strength: number;
    }>, candidates: number[]): {
        frequency: number;
        score: number;
    } | null;
    /**
     * Calculate harmonic score
     */
    calculateHarmonicScore(matches: Array<{
        frequency: number;
        strength: number;
        harmonicNumber: number;
    }>): number;
    /**
     * Detect octave errors
     */
    detectOctaveError(detected: number, expected: number, tolerance?: number): {
        isOctaveError: boolean;
        correctedFrequency: number;
    };
};
/**
 * Quick utility: Analyze harmonics
 */
export declare function analyzeHarmonics(signal: Float32Array, sampleRate?: number, options?: HarmonicAnalysisConfig): HarmonicResult | null;
/**
 * Harmonic analysis utilities
 */
export declare const HarmonicUtils: {
    /**
     * Calculate harmonic-to-noise ratio
     */
    calculateHNR(harmonics: Array<{
        amplitude: number;
    }>, noiseFloor: number): number;
    /**
     * Calculate spectral irregularity
     */
    calculateSpectralIrregularity(magnitude: Float32Array): number;
    /**
     * Calculate spectral flatness
     */
    calculateSpectralFlatness(magnitude: Float32Array): number;
    /**
     * Extract harmonic series
     */
    extractHarmonicSeries(fundamental: number, maxHarmonics?: number): number[];
};