/**
 * Pitch tracking and smoothing utilities
 *
 * This module provides temporal smoothing and tracking of pitch detection results
 * to improve stability and accuracy over time.
 */
/**
 * Configuration for pitch tracking
 */
export interface PitchTrackingConfig {
    sampleRate?: number;
    frameSize?: number;
    hopSize?: number;
    smoothingWindow?: number;
    medianFilterSize?: number;
    outlierThreshold?: number;
    minConfidence?: number;
    maxPitchJump?: number;
    useViterbi?: boolean;
    viterbiStates?: number;
    viterbiTransitions?: number;
}
/**
 * Tracked pitch result
 */
export interface TrackedPitch {
    frequency: number;
    confidence: number;
    clarity: number;
    timestamp: number;
    isStable: boolean;
    velocity: number;
    acceleration: number;
}
/**
 * Pitch tracking state
 */
export interface PitchTrackingState {
    history: TrackedPitch[];
    currentFrame: number;
    lastStablePitch: TrackedPitch | null;
    viterbiStates: number[];
    isInitialized: boolean;
}
/**
 * Main pitch tracking class
 */
export declare class PitchTracker {
    private config;
    private state;
    private medianFilter;
    private smoothingBuffer;
    constructor(config?: PitchTrackingConfig);
    /**
     * Process a new pitch detection result
     */
    processPitch(pitch: {
        frequency: number;
        confidence: number;
        clarity: number;
        timestamp: number;
    }): TrackedPitch | null;
    /**
     * Initialize the tracker with first pitch
     */
    private initializeTracker;
    /**
     * Detect and filter outliers
     */
    private detectOutliers;
    /**
     * Apply median filtering
     */
    private applyMedianFilter;
    /**
     * Apply temporal smoothing
     */
    private applyTemporalSmoothing;
    /**
     * Apply Viterbi tracking
     */
    private applyViterbiTracking;
    /**
     * Run Viterbi algorithm for pitch tracking
     */
    private runViterbiAlgorithm;
    /**
     * Calculate smoothed frequency
     */
    private calculateSmoothedFrequency;
    /**
     * Calculate smoothed confidence
     */
    private calculateSmoothedConfidence;
    /**
     * Calculate smoothed clarity
     */
    private calculateSmoothedClarity;
    /**
     * Calculate pitch stability
     */
    private calculateStability;
    /**
     * Calculate pitch velocity
     */
    private calculateVelocity;
    /**
     * Calculate pitch acceleration
     */
    private calculateAcceleration;
    /**
     * Update tracking state
     */
    private updateState;
    /**
     * Get current tracking state
     */
    getState(): Readonly<PitchTrackingState>;
    /**
     * Reset tracking state
     */
    reset(): void;
    /**
     * Update configuration
     */
    updateConfig(newConfig: Partial<PitchTrackingConfig>): void;
    /**
     * Get current configuration
     */
    getConfig(): Readonly<Required<PitchTrackingConfig>>;
}
/**
 * Utility functions for pitch tracking
 */
export declare const PitchTrackingUtils: {
    /**
     * Calculate pitch stability over a window
     */
    calculateStability(pitches: TrackedPitch[], windowSize?: number): number;
    /**
     * Detect pitch jumps
     */
    detectPitchJumps(pitches: TrackedPitch[], threshold?: number): number[];
    /**
     * Smooth pitch trajectory
     */
    smoothTrajectory(pitches: TrackedPitch[], windowSize?: number): TrackedPitch[];
    /**
     * Calculate pitch statistics
     */
    calculateStatistics(pitches: TrackedPitch[]): {
        mean: number;
        median: number;
        stdDev: number;
        min: number;
        max: number;
        range: number;
    };
};
/**
 * Quick utility function for pitch tracking
 */
export declare function trackPitch(pitch: {
    frequency: number;
    confidence: number;
    clarity: number;
    timestamp: number;
}, config?: PitchTrackingConfig): TrackedPitch | null;