/**
 * Quick frequency generation utility
 * @param {number} baseFreq - Base frequency in Hz
 * @param {string} intervalType - Type of intervals ('equal', 'ji5', etc.)
 * @param {number} numNotes - Number of notes to generate
 * @returns {Float32Array} Frequency array
 */
export function generateFrequencies(baseFreq?: number, intervalType?: string, numNotes?: number): Float32Array;
/**
 * Compare different tuning systems
 * @param {number} baseFreq - Base frequency
 * @param {Array<string>} systems - Systems to compare
 * @returns {Object} Comparison data
 */
export function compareTuningSystems(baseFreq?: number, systems?: Array<string>): any;
/**
 * Construct interval frequencies (convenience wrapper)
 *
 * @param {number} n_bins - Number of frequency bins
 * @param {number} fmin - Minimum frequency in Hz
 * @param {string|Array<number>} intervals - Interval specification
 * @param {number} bins_per_octave - Bins per octave (default: 12)
 * @param {number} tuning - Tuning offset (default: 0.0)
 * @param {boolean} sort - Sort intervals (default: true)
 * @returns {Float32Array} Frequency array
 */
export function interval_frequencies(n_bins: number, fmin: number, intervals: string | Array<number>, bins_per_octave?: number, tuning?: number, sort?: boolean): Float32Array;
/**
 * Construct p-limit intervals (convenience wrapper)
 *
 * @param {Array<number>} primes - Prime factors to use
 * @param {number} bins_per_octave - Bins per octave (default: 12)
 * @param {boolean} sort - Sort intervals (default: true)
 * @param {boolean} return_factors - Return prime factorizations (default: false)
 * @returns {Float32Array|Array<Object>} Interval ratios or factorizations
 */
export function plimit_intervals(primes: Array<number>, bins_per_octave?: number, sort?: boolean, return_factors?: boolean): Float32Array | Array<any>;
/**
 * Construct Pythagorean intervals (convenience wrapper)
 *
 * @param {number} bins_per_octave - Bins per octave (default: 12)
 * @param {boolean} sort - Sort intervals (default: true)
 * @param {boolean} return_factors - Return prime factorizations (default: false)
 * @returns {Float32Array|Array<Object>} Interval ratios or factorizations
 */
export function pythagorean_intervals(bins_per_octave?: number, sort?: boolean, return_factors?: boolean): Float32Array | Array<any>;
/**
 * Musical Interval Constructor Class
 * Handles equal temperament, just intonation, and Pythagorean tuning systems
 */
export class IntervalConstructor {
    _cache: Map<any, any>;
    COMMON_INTERVALS: {
        unison: number;
        minor_second: number;
        major_second: number;
        minor_third: number;
        major_third: number;
        perfect_fourth: number;
        tritone: number;
        perfect_fifth: number;
        minor_sixth: number;
        major_sixth: number;
        minor_seventh: number;
        major_seventh: number;
        octave: number;
    };
    /**
     * Simple cache decorator implementation
     * @private
     */
    private _cached;
    /**
     * Construct a set of frequencies from an interval set
     * @param {number} nBins - The number of frequencies to generate
     * @param {Object} options - Configuration options
     * @param {number} options.fmin - The minimum frequency (must be > 0)
     * @param {string|Array<number>} options.intervals - Interval specification
     * @param {number} options.binsPerOctave - Bins per octave (default: 12)
     * @param {number} options.tuning - Deviation from A440 in fractional bins (default: 0)
     * @param {boolean} options.sort - Sort intervals in ascending order (default: true)
     * @returns {Float32Array} The frequency array
     */
    intervalFrequencies(nBins: number, options?: {
        fmin: number;
        intervals: string | Array<number>;
        binsPerOctave: number;
        tuning: number;
        sort: boolean;
    }): Float32Array;
    /**
     * Generate Pythagorean intervals based on powers of 3
     * @param {Object} options - Configuration options
     * @param {number} options.binsPerOctave - Number of intervals to generate (default: 12)
     * @param {boolean} options.sort - Sort intervals ascending (default: true)
     * @param {boolean} options.returnFactors - Return prime factorization (default: false)
     * @returns {Float32Array|Array<Object>} Intervals or their factorizations
     */
    pythagoreanIntervals(options?: {
        binsPerOctave: number;
        sort: boolean;
        returnFactors: boolean;
    }): Float32Array | Array<any>;
    /**
     * Construct p-limit intervals using harmonic crystal growth algorithm
     * @param {Object} options - Configuration options
     * @param {Array<number>} options.primes - Prime factors to use
     * @param {number} options.binsPerOctave - Number of intervals (default: 12)
     * @param {boolean} options.sort - Sort intervals ascending (default: true)
     * @param {boolean} options.returnFactors - Return prime factorization (default: false)
     * @returns {Float32Array|Array<Object>} Intervals or their factorizations
     */
    plimitIntervals(options?: {
        primes: Array<number>;
        binsPerOctave: number;
        sort: boolean;
        returnFactors: boolean;
    }): Float32Array | Array<any>;
    /**
     * Generate well-tempered intervals (historical temperaments)
     * @param {string} temperament - Temperament name ('werckmeister', 'kirnberger', 'young')
     * @param {boolean} sort - Sort intervals
     * @returns {Float32Array} Interval ratios
     */
    wellTemperedIntervals(temperament?: string, sort?: boolean): Float32Array;
    /**
     * Compute harmonic distance between two intervals
     * @private
     */
    private _harmonicDistance;
    /**
     * Tie-breaking function for crystal growth algorithm
     * @private
     */
    private _crystalTieBreak;
    /**
     * Utility functions
     * @private
     */
    private _vectorKey;
    _vectorsEqual(a: any, b: any): any;
    /**
     * Convert interval ratios to cents
     * @param {Float32Array} ratios - Interval ratios
     * @returns {Float32Array} Intervals in cents
     */
    ratiosToCents(ratios: Float32Array): Float32Array;
    /**
     * Convert cents to interval ratios
     * @param {Array} cents - Intervals in cents
     * @returns {Float32Array} Interval ratios
     */
    centsToRatios(cents: any[]): Float32Array;
    /**
     * Get note names for intervals (Western 12-tone system)
     * @param {number} binsPerOctave - Number of divisions (default: 12)
     * @returns {Array<string>} Note names
     */
    getNoteNames(binsPerOctave?: number): Array<string>;
    /**
     * Analyze interval quality (consonance/dissonance)
     * @param {number} ratio - Interval ratio
     * @returns {Object} Analysis result
     */
    analyzeInterval(ratio: number): any;
}