export function frames_to_samples(frames: any, hop_length?: number, n_fft?: any): any;
/**
 * Convert audio samples to frame indices
 * @param {number|Array} samples - Sample indices
 * @param {number} hop_length - Hop length
 * @param {number} n_fft - FFT window size (optional)
 * @returns {number|Array} Frame indices
 */
export function samples_to_frames(samples: number | any[], hop_length?: number, n_fft?: number): number | any[];
/**
 * Convert frame indices to time (seconds)
 * @param {number|Array} frames - Frame indices
 * @param {number} sr - Sample rate
 * @param {number} hop_length - Hop length
 * @param {number} n_fft - FFT window size (optional)
 * @returns {number|Array} Time in seconds
 */
export function frames_to_time(frames: number | any[], sr?: number, hop_length?: number, n_fft?: number): number | any[];
/**
 * Convert time (seconds) to frame indices
 * @param {number|Array} times - Time in seconds
 * @param {number} sr - Sample rate
 * @param {number} hop_length - Hop length
 * @param {number} n_fft - FFT window size (optional)
 * @returns {number|Array} Frame indices
 */
export function time_to_frames(times: number | any[], sr?: number, hop_length?: number, n_fft?: number): number | any[];
/**
 * Convert sample indices to time (seconds)
 * @param {number|Array} samples - Sample indices
 * @param {number} sr - Sample rate
 * @returns {number|Array} Time in seconds
 */
export function samples_to_time(samples: number | any[], sr?: number): number | any[];
/**
 * Convert time (seconds) to sample indices
 * @param {number|Array} times - Time in seconds
 * @param {number} sr - Sample rate
 * @returns {number|Array} Sample indices
 */
export function time_to_samples(times: number | any[], sr?: number): number | any[];
/**
 * Convert Hz to MIDI note number
 * @param {number|Array} frequencies - Frequency in Hz
 * @returns {number|Array} MIDI note number
 */
export function hz_to_midi(frequencies: number | any[]): number | any[];
/**
 * Convert MIDI note number to Hz
 * @param {number|Array} notes - MIDI note number
 * @returns {number|Array} Frequency in Hz
 */
export function midi_to_hz(notes: number | any[]): number | any[];
/**
 * Convert MIDI note number to note name
 * @param {number|Array} midi - MIDI note number(s)
 * @param {boolean} octave - Include octave number (default: true)
 * @param {boolean} cents - Include cent deviation (default: false)
 * @returns {string|Array} Note name(s) (e.g., 'A4', 'C#5')
 */
export function midi_to_note(midi: number | any[], octave?: boolean, cents?: boolean): string | any[];
/**
 * Convert note name to MIDI note number
 * @param {string|Array} note - Note name(s) (e.g., 'A4', 'C#5')
 * @param {boolean} round_midi - Round to integer MIDI values (default: true)
 * @returns {number|Array} MIDI note number(s)
 */
export function note_to_midi(note: string | any[], round_midi?: boolean): number | any[];
/**
 * Convert Hz to note name
 * @param {number|Array} hz - Frequency in Hz
 * @param {boolean} octave - Include octave number (default: true)
 * @param {boolean} cents - Include cent deviation (default: false)
 * @returns {string|Array} Note name(s)
 */
export function hz_to_note(hz: number | any[], octave?: boolean, cents?: boolean): string | any[];
/**
 * Convert note name to Hz
 * @param {string|Array} note - Note name(s) (e.g., 'A4', 'C#5')
 * @returns {number|Array} Frequency in Hz
 */
export function note_to_hz(note: string | any[]): number | any[];
/**
 * Convert Hz to octaves (relative to C0)
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {number} tuning - Tuning frequency for A4 (default: 440.0)
 * @returns {number|Array} Octaves
 */
export function hz_to_octs(frequencies: number | any[], tuning?: number): number | any[];
/**
 * Convert octaves to Hz
 * @param {number|Array} octs - Octaves (relative to C0)
 * @param {number} tuning - Tuning frequency for A4 (default: 440.0)
 * @returns {number|Array} Frequency in Hz
 */
export function octs_to_hz(octs: number | any[], tuning?: number): number | any[];
/**
 * Convert amplitude to decibels
 * @param {number|Array} amplitude - Amplitude value(s)
 * @param {number} ref - Reference amplitude (default: 1.0)
 * @param {number} amin - Minimum amplitude threshold (default: 1e-5)
 * @param {number} top_db - Maximum dB range (default: 80.0)
 * @returns {number|Array} dB value(s)
 */
export function amplitude_to_db(amplitude: number | any[], ref?: number, amin?: number, top_db?: number): number | any[];
/**
 * Convert decibels to amplitude
 * @param {number|Array} db - dB value(s)
 * @param {number} ref - Reference amplitude (default: 1.0)
 * @returns {number|Array} Amplitude value(s)
 */
export function db_to_amplitude(db: number | any[], ref?: number): number | any[];
/**
 * Convert power to decibels
 * @param {number|Array|Array<Array>} power - Power value(s) or power spectrogram
 * @param {number} ref - Reference power (default: 1.0)
 * @param {number} amin - Minimum power threshold (default: 1e-10)
 * @param {number} top_db - Maximum dB range (default: 80.0)
 * @returns {number|Array|Array<Array>} dB value(s)
 */
export function power_to_db(power: number | any[] | Array<any[]>, ref?: number, amin?: number, top_db?: number): number | any[] | Array<any[]>;
/**
 * Convert decibels to power
 * @param {number|Array|Array<Array>} db - dB value(s) or dB spectrogram
 * @param {number} ref - Reference power (default: 1.0)
 * @returns {number|Array|Array<Array>} Power value(s)
 */
export function db_to_power(db: number | any[] | Array<any[]>, ref?: number): number | any[] | Array<any[]>;
/**
 * A-weighting of frequency
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {number} min_db - Minimum dB value (default: -80.0)
 * @returns {number|Array} A-weighting in dB
 */
export function a_weighting(frequencies: number | any[], min_db?: number): number | any[];
/**
 * B-weighting of frequency
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {number} min_db - Minimum dB value (default: -80.0)
 * @returns {number|Array} B-weighting in dB
 */
export function b_weighting(frequencies: number | any[], min_db?: number): number | any[];
/**
 * C-weighting of frequency
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {number} min_db - Minimum dB value (default: -80.0)
 * @returns {number|Array} C-weighting in dB
 */
export function c_weighting(frequencies: number | any[], min_db?: number): number | any[];
/**
 * D-weighting of frequency
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {number} min_db - Minimum dB value (default: -80.0)
 * @returns {number|Array} D-weighting in dB
 */
export function d_weighting(frequencies: number | any[], min_db?: number): number | any[];
/**
 * Perceptual weighting curve (approximate)
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {string} kind - Weighting kind ('A', 'B', 'C', 'D') (default: 'A')
 * @param {number} min_db - Minimum dB value (default: -80.0)
 * @returns {number|Array} Perceptual weighting in dB
 */
export function perceptual_weighting(frequencies: number | any[], kind?: string, min_db?: number): number | any[];
/**
 * Compute FFT frequencies
 * @param {number} sr - Sample rate
 * @param {number} n_fft - FFT size
 * @returns {Float32Array} Frequency bins in Hz
 */
export function fft_frequencies(sr?: number, n_fft?: number): Float32Array;
/**
 * Compute CQT (Constant-Q Transform) frequencies
 * @param {number} n_bins - Number of frequency bins
 * @param {number} fmin - Minimum frequency (default: C1 ~= 32.70 Hz)
 * @param {number} bins_per_octave - Number of bins per octave (default: 12)
 * @param {number} tuning - Tuning offset in fractions of a bin (default: 0.0)
 * @returns {Float32Array} CQT frequency bins in Hz
 */
export function cqt_frequencies(n_bins: number, fmin?: number, bins_per_octave?: number, tuning?: number): Float32Array;
/**
 * Compute Fourier tempogram frequencies
 * @param {number} sr - Sample rate
 * @param {number} win_length - Window length for temporal autocorrelation
 * @param {number} hop_length - Hop length for frame analysis (default: 512)
 * @returns {Float32Array} Tempo frequencies in BPM
 */
export function fourier_tempo_frequencies(sr?: number, win_length?: number, hop_length?: number): Float32Array;
/**
 * Convert BPM to lag (in frames)
 * @param {number|Array} bpm - Tempo in BPM
 * @param {number} sr - Sample rate
 * @param {number} hop_length - Hop length
 * @returns {number|Array} Lag in frames
 */
export function tempo_to_lag(bpm: number | any[], sr?: number, hop_length?: number): number | any[];
/**
 * Convert lag (in frames) to BPM
 * @param {number|Array} lag - Lag in frames
 * @param {number} sr - Sample rate
 * @param {number} hop_length - Hop length
 * @returns {number|Array} Tempo in BPM
 */
export function lag_to_tempo(lag: number | any[], sr?: number, hop_length?: number): number | any[];
/**
 * Convert block indices to frame indices
 * @param {number|Array} blocks - Block indices
 * @param {number} block_length - Block length in frames
 * @returns {number|Array} Frame indices
 */
export function blocks_to_frames(blocks: number | any[], block_length: number): number | any[];
/**
 * Convert block indices to sample indices
 * @param {number|Array} blocks - Block indices
 * @param {number} block_length - Block length in frames
 * @param {number} hop_length - Hop length
 * @returns {number|Array} Sample indices
 */
export function blocks_to_samples(blocks: number | any[], block_length: number, hop_length: number): number | any[];
/**
 * Convert block indices to time (in seconds)
 * @param {number|Array} blocks - Block indices
 * @param {number} block_length - Block length in frames
 * @param {number} hop_length - Hop length
 * @param {number} sr - Sample rate
 * @returns {number|Array} Time in seconds
 */
export function blocks_to_time(blocks: number | any[], block_length: number, hop_length: number, sr: number): number | any[];
/**
 * Compute the frequencies (in BPM) corresponding to LAG-tempogram bins.
 * Lag-tempogram bin k is autocorrelation lag k, so
 * bpm[k] = 60 * sr / (hop_length * k), and bin 0 (lag 0) is +Infinity.
 *
 * Tier-3 repair (2026-07-02): the previous body computed a LINEAR Fourier
 * frequency grid (fourier_tempo_frequencies math with a fabricated
 * win_length = 2*(n_bins-1)) — every BPM axis drawn with it was wrong.
 * For Fourier tempograms use fourier_tempo_frequencies().
 *
 * @param {number} n_bins - Number of lag bins (tempogram rows)
 * @param {number} hop_length - Hop length of the onset envelope
 * @param {number} sr - Sample rate
 * @returns {Float64Array} Tempo frequencies in BPM (bin 0 = Infinity)
 */
export function tempo_frequencies(n_bins: number, hop_length?: number, sr?: number): Float64Array;
/**
 * Return an array of time values to match the time axis from a feature matrix
 * @param {Array|number} X - Feature matrix or number of frames
 * @param {number} sr - Sample rate
 * @param {number} hop_length - Hop length
 * @param {number|null} n_fft - FFT size
 * @param {number} axis - Time axis (default -1)
 * @returns {Float32Array} Array of time values
 */
export function times_like(X: any[] | number, sr?: number, hop_length?: number, n_fft?: number | null, axis?: number): Float32Array;
/**
 * Return an array of sample indices to match the time axis from a feature matrix
 * @param {Array|number} X - Feature matrix or number of frames
 * @param {number} hop_length - Hop length
 * @param {number|null} n_fft - FFT size
 * @param {number} axis - Time axis (default -1)
 * @returns {Int32Array} Array of sample indices
 */
export function samples_like(X: any[] | number, hop_length?: number, n_fft?: number | null, axis?: number): Int32Array;
/**
 * Compute the mel-scale frequencies
 * @param {number} n_mels - Number of mel bins
 * @param {number} fmin - Minimum frequency
 * @param {number} fmax - Maximum frequency
 * @param {boolean} htk - Use HTK formula
 * @returns {Float32Array} Mel frequencies in Hz
 */
export function mel_frequencies(n_mels?: number, fmin?: number, fmax?: number, htk?: boolean): Float32Array;
/**
 * Convert Hz to Mel scale
 * @param {number|Array} frequencies - Frequencies in Hz (scalar or array)
 * @param {boolean} htk - Use HTK formula instead of Slaney
 * @returns {number|Array} Frequencies in Mel scale
 */
export function hz_to_mel(frequencies: number | any[], htk?: boolean): number | any[];
/**
 * Convert Mel scale to Hz
 * @param {number|Array} mels - Frequencies in Mel scale (scalar or array)
 * @param {boolean} htk - Use HTK formula instead of Slaney
 * @returns {number|Array} Frequencies in Hz
 */
export function mel_to_hz(mels: number | any[], htk?: boolean): number | any[];
/**
 * Z-weighting (flat/no weighting) for frequency analysis
 * @param {number|Array} frequencies - Frequencies in Hz (scalar or array)
 * @param {number} min_db - Minimum dB value (not used for Z-weighting, included for API compatibility)
 * @returns {number|Array} Weighting values (all zeros for Z-weighting)
 */
export function z_weighting(frequencies: number | any[], min_db?: number): number | any[];
/**
 * Convert reference pitch A4 frequency to tuning deviation
 * @param {number|Array} A4 - Reference frequency for A4 in Hz (scalar or array)
 * @param {number} bins_per_octave - Number of bins per octave
 * @returns {number|Array} Tuning deviation in fractional bins
 */
export function A4_to_tuning(A4: number | any[], bins_per_octave?: number): number | any[];
/**
 * Convert tuning deviation to A4 reference frequency
 * @param {number|Array} tuning - Tuning deviation in fractional bins (scalar or array)
 * @param {number} bins_per_octave - Number of bins per octave
 * @returns {number|Array} Reference frequency for A4 in Hz
 */
export function tuning_to_A4(tuning: number | any[], bins_per_octave?: number): number | any[];
/**
 * General frequency weighting function (wrapper for A/B/C/D/Z weightings)
 * @param {number|Array} frequencies - Frequencies in Hz (scalar or array)
 * @param {string} kind - Weighting type: 'A', 'B', 'C', 'D', or 'Z'
 * @param {number} min_db - Minimum dB value
 * @returns {number|Array} Weighting values in dB
 */
export function frequency_weighting(frequencies: number | any[], kind?: string, min_db?: number): number | any[];
/**
 * Compute multiple frequency weightings at once
 * @param {number|Array} frequencies - Frequencies in Hz (scalar or array)
 * @param {Array<string>} kinds - Array of weighting types, e.g., ['Z', 'A', 'C']
 * @param {number} min_db - Minimum dB value
 * @returns {Array} Array of weighting arrays, one per kind
 *
 * @example
 * multi_frequency_weighting([100, 1000, 10000], ['Z', 'A', 'C'])
 * // Returns [[0, 0, 0], [-19.1, 0, 0], [-0.2, 0, -0.2]]
 */
export function multi_frequency_weighting(frequencies: number | any[], kinds?: Array<string>, min_db?: number): any[];
/**
 * A-weighting of frequency
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {number} min_db - Minimum dB value (default: -80.0)
 * @returns {number|Array} A-weighting in dB
 */
export function A_weighting(frequencies: number | any[], min_db?: number): number | any[];
/**
 * B-weighting of frequency
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {number} min_db - Minimum dB value (default: -80.0)
 * @returns {number|Array} B-weighting in dB
 */
export function B_weighting(frequencies: number | any[], min_db?: number): number | any[];
/**
 * C-weighting of frequency
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {number} min_db - Minimum dB value (default: -80.0)
 * @returns {number|Array} C-weighting in dB
 */
export function C_weighting(frequencies: number | any[], min_db?: number): number | any[];
/**
 * D-weighting of frequency
 * @param {number|Array} frequencies - Frequency in Hz
 * @param {number} min_db - Minimum dB value (default: -80.0)
 * @returns {number|Array} D-weighting in dB
 */
export function D_weighting(frequencies: number | any[], min_db?: number): number | any[];
/**
 * Z-weighting (flat/no weighting) for frequency analysis
 * @param {number|Array} frequencies - Frequencies in Hz (scalar or array)
 * @param {number} min_db - Minimum dB value (not used for Z-weighting, included for API compatibility)
 * @returns {number|Array} Weighting values (all zeros for Z-weighting)
 */
export function Z_weighting(frequencies: number | any[], min_db?: number): number | any[];