/**
 * Normalize features using L1, L2, or infinity norm
 * @param {Array<Array<number>>} features - Feature matrix [n_features x n_frames]
 * @param {string} norm - Normalization type ('l1', 'l2', 'inf')
 * @param {number} axis - Axis along which to normalize (0 or 1)
 * @returns {Array<Array<number>>} Normalized features
 */
export function normalize_features(features: Array<Array<number>>, norm?: string, axis?: number): Array<Array<number>>;
/**
 * Compute zero crossing rate for audio frames
 * @param {Float32Array} y - Audio signal
 * @param {number} frame_length - Frame length in samples
 * @param {number} hop_length - Hop length in samples
 * @param {boolean} center - Whether to center frames
 * @returns {Float32Array} Zero crossing rate for each frame
 */
export function zero_crossing_rate(y: Float32Array, frame_length?: number, hop_length?: number, center?: boolean): Float32Array;
/**
 * Compute RMS (Root Mean Square) energy for audio frames
 * @param {Float32Array} y - Audio signal
 * @param {number} frame_length - Frame length in samples
 * @param {number} hop_length - Hop length in samples
 * @param {boolean} center - Whether to center frames
 * @returns {Float32Array} RMS energy for each frame
 */
export function rms(y: Float32Array, frame_length?: number, hop_length?: number, center?: boolean): Float32Array;
/**
 * Harmonic-Percussive Source Separation using median filtering
 * @param {Array<Array<number>>} S - Magnitude spectrogram [freq x time]
 * @param {number} kernel_size - Median filter kernel size
 * @param {number} power - Power for soft masking
 * @param {boolean} mask - Whether to return soft masks
 * @returns {Object} {harmonic, percussive} components
 */
export function hpss(S: Array<Array<number>>, kernel_size?: number, power?: number, mask?: boolean): any;
/**
 * Pitch shift audio using phase vocoder
 * @param {Float32Array} y - Audio signal
 * @param {number} sr - Sample rate
 * @param {number} n_steps - Number of semitones to shift
 * @param {number} bins_per_octave - Number of bins per octave
 * @returns {Float32Array} Pitch-shifted audio
 */
export function pitch_shift(y: Float32Array, sr: number, n_steps: number, bins_per_octave?: number): Float32Array;
/**
 * Phase vocoder for time-stretching an STFT matrix.
 * SHIM (Wave 5A): delegates to the canonical implementation
 * in src/effects/index.js (fixture-gated: phase_vocoder.json). The legacy
 * local copy ignored the input phase entirely (magnitude-only robotization)
 * and skipped magnitude interpolation.
 * @param {Array} D - STFT matrix [freq][time] of {real, imag} bins
 * @param {number} rate - Time stretch/compression rate (>1 faster)
 * @returns {Array} Modified STFT matrix [freq][ceil(time/rate)]
 */
export function phase_vocoder(D: any[], rate: number): any[];
/**
 * Detect fundamental frequency using autocorrelation
 * @param {Float32Array} y - Audio signal
 * @param {number} sr - Sample rate
 * @param {number} hop_length - Hop length for frame analysis
 * @param {number} fmin - Minimum frequency to detect
 * @param {number} fmax - Maximum frequency to detect
 * @returns {Object} {pitches, confidences} arrays
 */
export function monophonic_pitch_detect(y: Float32Array, sr?: number, hop_length?: number, fmin?: number, fmax?: number): any;
/**
 * Compute autocorrelation of a signal
 * @param {Float32Array} buffer - Input signal
 * @returns {Float32Array} Autocorrelation function
 */
export function autocorrelate(buffer: Float32Array): Float32Array;
/**
 * Simple polynomial fitting (linear regression for degree=1)
 * @param {Array<number>} x - X values
 * @param {Array<number>} y - Y values
 * @param {number} degree - Polynomial degree (1 for linear)
 * @returns {Array<number>} Polynomial coefficients
 */
export function polyfit(x: Array<number>, y: Array<number>, degree?: number): Array<number>;
/**
 * Generate linearly spaced array
 * @param {number} start - Start value
 * @param {number} stop - Stop value
 * @param {number} num - Number of values
 * @returns {Array<number>} Linearly spaced array
 */
export function linspace(start: number, stop: number, num: number): Array<number>;
/**
 * Find local maxima in a 1D signal
 * @param {Array<number>} signal - Input signal
 * @param {number} min_distance - Minimum distance between peaks
 * @param {number} threshold - Minimum peak height
 * @returns {Array<number>} Peak indices
 */
export function find_peaks(signal: Array<number>, min_distance?: number, threshold?: number): Array<number>;
/**
 * Griffin-Lim algorithm for phase reconstruction
 *
 * Approximate magnitude spectrogram inversion using iterative phase estimation.
 *
 * @param {Array<Array<number>>} S - Magnitude spectrogram [freq x time]
 * @param {number} n_iter - Number of iterations (default: 32)
 * @param {number} hop_length - Hop length for STFT (default: 512)
 * @param {number|null} win_length - Window length (default: null, uses n_fft)
 * @param {number|null} n_fft - FFT size (default: null, inferred from S)
 * @param {string} window - Window function (default: 'hann')
 * @param {boolean} center - Center the frames (default: true)
 * @param {string|null} dtype - Data type (default: null)
 * @param {number|null} length - Output length in samples (default: null)
 * @param {string} pad_mode - Padding mode (default: 'constant')
 * @param {number} momentum - Fast Griffin-Lim momentum (default: 0.99)
 * @param {string|null} init - Initialization ('random' or null, default: 'random')
 * @param {number|null} random_state - Random seed (default: null)
 * @returns {Float32Array} Reconstructed audio signal
 */
export function griffinlim(S: Array<Array<number>>, n_iter?: number, hop_length?: number, win_length?: number | null, n_fft?: number | null, window?: string, center?: boolean, dtype?: string | null, length?: number | null, pad_mode?: string, momentum?: number, init?: string | null, random_state?: number | null): Float32Array;
/**
 * Per-Channel Energy Normalization (PCEN)
 *
 * Applies adaptive gain control and dynamic range compression for robust feature extraction.
 *
 * @param {Array<Array<number>>} S - Input spectrogram [freq x time]
 * @param {number} sr - Sample rate (default: 22050)
 * @param {number} hop_length - Hop length (default: 512)
 * @param {number} gain - Gain normalization exponent (default: 0.98)
 * @param {number} bias - Bias constant (default: 2)
 * @param {number} power - Compression exponent (default: 0.5)
 * @param {number} time_constant - AGC time constant in seconds (default: 0.4)
 * @param {number} eps - Numerical stability constant (default: 1e-6)
 * @param {number|null} b - Smoothing coefficient (default: null, computed from time_constant)
 * @param {number} max_size - Max filter size for smoothing (default: 1)
 * @param {Array|null} ref - Reference values for normalization (default: null)
 * @param {number} axis - Time axis (default: -1)
 * @param {number|null} max_axis - Max pooling axis (default: null)
 * @param {Array|null} zi - Initial filter state (default: null)
 * @param {boolean} return_zf - Return final filter state (default: false)
 * @returns {Array<Array<number>>|Object} PCEN output or {output, zf} if return_zf
 */
export function pcen(S: Array<Array<number>>, sr?: number, hop_length?: number, gain?: number, bias?: number, power?: number, time_constant?: number, eps?: number, b?: number | null, max_size?: number, ref?: any[] | null, axis?: number, max_axis?: number | null, zi?: any[] | null, return_zf?: boolean): Array<Array<number>> | any;
/**
 * Separate magnitude and phase from a complex spectrogram
 *
 * @param {Array<Array<{real: number, imag: number}>>} D - Complex spectrogram
 * @param {number} power - Magnitude power (default: 1)
 * @returns {Object} {magnitude: Array, phase: Array}
 */
export function magphase(D: Array<Array<{
    real: number;
    imag: number;
}>>, power?: number): any;
/**
 * Fast Mellin Transform (FMT)
 *
 * Compute the FMT for time-scale analysis (useful for tempo-invariant features).
 *
 * @param {Float32Array|Array<number>} y - Input signal
 * @param {number} t_min - Minimum period (default: 0.5)
 * @param {number|null} n_fmt - Number of FMT bins (default: null, uses signal length)
 * @param {string} kind - Interpolation kind (default: 'cubic')
 * @param {number} beta - FMT parameter (default: 0.5)
 * @param {number} over_sample - Oversampling factor (default: 1)
 * @param {number} axis - Axis to transform (default: -1)
 * @returns {Array<{real: number, imag: number}>} FMT coefficients
 */
export function fmt(y: Float32Array | Array<number>, t_min?: number, n_fmt?: number | null, kind?: string, beta?: number, over_sample?: number, axis?: number): Array<{
    real: number;
    imag: number;
}>;
/**
 * Time-frequency reassigned spectrogram
 *
 * Compute spectrogram with reassigned time and frequency coordinates
 * for improved time-frequency resolution.
 *
 * @param {Float32Array} y - Audio signal
 * @param {number} sr - Sample rate (default: 22050)
 * @param {Array|null} S - Precomputed spectrogram (default: null)
 * @param {number} n_fft - FFT size (default: 2048)
 * @param {number|null} hop_length - Hop length (default: null)
 * @param {number|null} win_length - Window length (default: null)
 * @param {string} window - Window function (default: 'hann')
 * @param {boolean} center - Center frames (default: true)
 * @param {boolean} reassign_frequencies - Reassign frequencies (default: true)
 * @param {boolean} reassign_times - Reassign times (default: true)
 * @param {number} ref_power - Reference power for dB conversion (default: 1e-6)
 * @param {boolean} fill_nan - Fill NaN values with zeros (default: false)
 * @param {boolean} clip - Clip reassigned values to valid range (default: true)
 * @param {string|null} dtype - Data type (default: null)
 * @param {string} pad_mode - Padding mode (default: 'constant')
 * @returns {Object} {spectrogram, frequencies, times}
 */
export function reassigned_spectrogram(y: Float32Array, sr?: number, S?: any[] | null, n_fft?: number, hop_length?: number | null, win_length?: number | null, window?: string, center?: boolean, reassign_frequencies?: boolean, reassign_times?: boolean, ref_power?: number, fill_nan?: boolean, clip?: boolean, dtype?: string | null, pad_mode?: string): any;
/**
 * Overlap-add operation for inverse STFT and Griffin-Lim
 * The __overlap_add helper
 *
 * Accumulates windowed frames into output buffer using overlap-add method.
 * This is the core operation for combining overlapping STFT frames back into
 * a time-domain signal.
 *
 * @private
 * @param {Float32Array|Array<number>} y - Pre-allocated output buffer [n_samples]
 * @param {Float32Array|Array<number>} ytmp - Windowed frame to add [frame_length]
 * @param {number} hop_length - Hop length in samples
 * @param {number} frame_idx - Current frame index
 * @returns {void} Modifies y in-place
 */
export function __overlap_add(y: Float32Array | Array<number>, ytmp: Float32Array | Array<number>, hop_length: number, frame_idx: number): void;
/**
 * Compute instantaneous frequencies for reassigned spectrogram
 * The __reassign_frequencies helper
 *
 * Uses the method from Flandrin et al. (2002) to compute frequency reassignments
 * based on the derivative of the analysis window.
 *
 * @private
 * @param {Float32Array|Array<number>} y - Audio signal
 * @param {number} sr - Sample rate in Hz
 * @param {Array<Array<{real: number, imag: number}>>|null} S - Pre-computed STFT (optional)
 * @param {number} n_fft - FFT window size
 * @param {number|null} hop_length - Hop length (default: n_fft/4)
 * @param {number|null} win_length - Window length (default: n_fft)
 * @param {string} window - Window type ('hann', 'hamming', etc.)
 * @param {boolean} center - Whether to center frames
 * @param {any} dtype - Data type (unused in JS)
 * @param {string} pad_mode - Padding mode
 * @returns {{S: Array, freqs_reassigned: Array}} STFT and reassigned frequencies
 */
export function __reassign_frequencies(y: Float32Array | Array<number>, sr?: number, S?: Array<Array<{
    real: number;
    imag: number;
}>> | null, n_fft?: number, hop_length?: number | null, win_length?: number | null, window?: string, center?: boolean, dtype?: any, pad_mode?: string): {
    S: any[];
    freqs_reassigned: any[];
};
/**
 * Compute time reassignments for reassigned spectrogram
 * The __reassign_times helper
 *
 * Computes time-domain reassignment using time-weighted window STFT.
 *
 * @private
 * @param {Float32Array|Array<number>} y - Audio signal
 * @param {number} sr - Sample rate in Hz
 * @param {Array<Array<{real: number, imag: number}>>|null} S - Pre-computed STFT (optional)
 * @param {number} n_fft - FFT window size
 * @param {number|null} hop_length - Hop length (default: n_fft/4)
 * @param {number|null} win_length - Window length (default: n_fft)
 * @param {string} window - Window type
 * @param {boolean} center - Whether to center frames
 * @param {any} dtype - Data type (unused in JS)
 * @param {string} pad_mode - Padding mode
 * @returns {{S: Array, times_reassigned: Array}} STFT and reassigned times
 */
export function __reassign_times(y: Float32Array | Array<number>, sr?: number, S?: Array<Array<{
    real: number;
    imag: number;
}>> | null, n_fft?: number, hop_length?: number | null, win_length?: number | null, window?: string, center?: boolean, dtype?: any, pad_mode?: string): {
    S: any[];
    times_reassigned: any[];
};
/**
 * Compute magnitude spectrogram from audio or STFT
 * The _spectrogram helper
 *
 * Internal helper that retrieves or computes a magnitude spectrogram,
 * handling both audio input and pre-computed STFT.
 *
 * @private
 * @param {Float32Array|Array<number>|null} y - Audio signal (optional if S provided)
 * @param {Array<Array<{real: number, imag: number}>>|null} S - Pre-computed STFT (optional if y provided)
 * @param {number} n_fft - FFT window size (default: 2048)
 * @param {number} hop_length - Hop length (default: 512)
 * @param {number} power - Exponent for magnitude (1=magnitude, 2=power) (default: 1)
 * @param {number|null} win_length - Window length (default: n_fft)
 * @param {string} window - Window type (default: 'hann')
 * @param {boolean} center - Whether to center frames (default: true)
 * @param {string} pad_mode - Padding mode (default: 'constant')
 * @returns {{S_mag: Array<Array<number>>, n_fft: number}} Magnitude spectrogram and n_fft
 */
export function _spectrogram(y?: Float32Array | Array<number> | null, S?: Array<Array<{
    real: number;
    imag: number;
}>> | null, n_fft?: number, hop_length?: number, power?: number, win_length?: number | null, window?: string, center?: boolean, pad_mode?: string): {
    S_mag: Array<Array<number>>;
    n_fft: number;
};