@libraz/libsonare 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,831 @@
+/**
+ * sonare - Audio Analysis Library
+ *
+ * @example
+ * ```typescript
+ * import { init, detectBpm, detectKey, analyze } from '@libraz/sonare';
+ *
+ * await init();
+ *
+ * // Detect BPM from audio samples
+ * const bpm = detectBpm(samples, sampleRate);
+ *
+ * // Detect musical key
+ * const key = detectKey(samples, sampleRate);
+ *
+ * // Full analysis
+ * const result = analyze(samples, sampleRate);
+ * ```
+ */
+/**
+ * Progress callback for analysis progress reporting.
+ * @param progress - Progress value (0.0 to 1.0)
+ * @param stage - Current analysis stage name
+ */
+export type ProgressCallback = (progress: number, stage: string) => void;
+/**
+ * Pitch class enum (C=0, C#=1, ..., B=11)
+ */
+export declare const PitchClass: {
+    readonly C: 0;
+    readonly Cs: 1;
+    readonly D: 2;
+    readonly Ds: 3;
+    readonly E: 4;
+    readonly F: 5;
+    readonly Fs: 6;
+    readonly G: 7;
+    readonly Gs: 8;
+    readonly A: 9;
+    readonly As: 10;
+    readonly B: 11;
+};
+export type PitchClass = (typeof PitchClass)[keyof typeof PitchClass];
+/**
+ * Musical mode
+ */
+export declare const Mode: {
+    readonly Major: 0;
+    readonly Minor: 1;
+};
+export type Mode = (typeof Mode)[keyof typeof Mode];
+/**
+ * Chord quality
+ */
+export declare const ChordQuality: {
+    readonly Major: 0;
+    readonly Minor: 1;
+    readonly Diminished: 2;
+    readonly Augmented: 3;
+    readonly Dominant7: 4;
+    readonly Major7: 5;
+    readonly Minor7: 6;
+    readonly Sus2: 7;
+    readonly Sus4: 8;
+};
+export type ChordQuality = (typeof ChordQuality)[keyof typeof ChordQuality];
+/**
+ * Section type
+ */
+export declare const SectionType: {
+    readonly Intro: 0;
+    readonly Verse: 1;
+    readonly PreChorus: 2;
+    readonly Chorus: 3;
+    readonly Bridge: 4;
+    readonly Instrumental: 5;
+    readonly Outro: 6;
+};
+export type SectionType = (typeof SectionType)[keyof typeof SectionType];
+/**
+ * Detected musical key
+ */
+export interface Key {
+    root: PitchClass;
+    mode: Mode;
+    confidence: number;
+    name: string;
+    shortName: string;
+}
+/**
+ * Detected beat
+ */
+export interface Beat {
+    time: number;
+    strength: number;
+}
+/**
+ * Detected chord
+ */
+export interface Chord {
+    root: PitchClass;
+    quality: ChordQuality;
+    start: number;
+    end: number;
+    confidence: number;
+    name: string;
+}
+/**
+ * Detected section
+ */
+export interface Section {
+    type: SectionType;
+    start: number;
+    end: number;
+    energyLevel: number;
+    confidence: number;
+    name: string;
+}
+/**
+ * Timbre characteristics
+ */
+export interface Timbre {
+    brightness: number;
+    warmth: number;
+    density: number;
+    roughness: number;
+    complexity: number;
+}
+/**
+ * Dynamics characteristics
+ */
+export interface Dynamics {
+    dynamicRangeDb: number;
+    loudnessRangeDb: number;
+    crestFactor: number;
+    isCompressed: boolean;
+}
+/**
+ * Time signature
+ */
+export interface TimeSignature {
+    numerator: number;
+    denominator: number;
+    confidence: number;
+}
+/**
+ * Rhythm features
+ */
+export interface RhythmFeatures {
+    syncopation: number;
+    grooveType: string;
+    patternRegularity: number;
+}
+/**
+ * Complete analysis result
+ */
+export interface AnalysisResult {
+    bpm: number;
+    bpmConfidence: number;
+    key: Key;
+    timeSignature: TimeSignature;
+    beats: Beat[];
+    chords: Chord[];
+    sections: Section[];
+    timbre: Timbre;
+    dynamics: Dynamics;
+    rhythm: RhythmFeatures;
+    form: string;
+}
+/**
+ * HPSS (Harmonic-Percussive Source Separation) result
+ */
+export interface HpssResult {
+    harmonic: Float32Array;
+    percussive: Float32Array;
+    sampleRate: number;
+}
+/**
+ * STFT (Short-Time Fourier Transform) result
+ */
+export interface StftResult {
+    nBins: number;
+    nFrames: number;
+    nFft: number;
+    hopLength: number;
+    sampleRate: number;
+    magnitude: Float32Array;
+    power: Float32Array;
+}
+/**
+ * Mel spectrogram result
+ */
+export interface MelSpectrogramResult {
+    nMels: number;
+    nFrames: number;
+    sampleRate: number;
+    hopLength: number;
+    power: Float32Array;
+    db: Float32Array;
+}
+/**
+ * MFCC result
+ */
+export interface MfccResult {
+    nMfcc: number;
+    nFrames: number;
+    coefficients: Float32Array;
+}
+/**
+ * Chroma features result
+ */
+export interface ChromaResult {
+    nChroma: number;
+    nFrames: number;
+    sampleRate: number;
+    hopLength: number;
+    features: Float32Array;
+    meanEnergy: number[];
+}
+/**
+ * Pitch detection result
+ */
+export interface PitchResult {
+    f0: Float32Array;
+    voicedProb: Float32Array;
+    voicedFlag: boolean[];
+    nFrames: number;
+    medianF0: number;
+    meanF0: number;
+}
+/**
+ * Initialize the WASM module.
+ * Must be called before using any analysis functions.
+ *
+ * @param options - Optional module configuration
+ * @returns Promise that resolves when initialization is complete
+ */
+export declare function init(options?: {
+    locateFile?: (path: string, prefix: string) => string;
+}): Promise<void>;
+/**
+ * Check if the module is initialized.
+ */
+export declare function isInitialized(): boolean;
+/**
+ * Get the library version.
+ */
+export declare function version(): string;
+/**
+ * Detect BPM from audio samples.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @returns Detected BPM
+ */
+export declare function detectBpm(samples: Float32Array, sampleRate: number): number;
+/**
+ * Detect musical key from audio samples.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @returns Detected key
+ */
+export declare function detectKey(samples: Float32Array, sampleRate: number): Key;
+/**
+ * Detect onset times from audio samples.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @returns Array of onset times in seconds
+ */
+export declare function detectOnsets(samples: Float32Array, sampleRate: number): Float32Array;
+/**
+ * Detect beat times from audio samples.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @returns Array of beat times in seconds
+ */
+export declare function detectBeats(samples: Float32Array, sampleRate: number): Float32Array;
+/**
+ * Perform complete music analysis.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @returns Complete analysis result
+ */
+export declare function analyze(samples: Float32Array, sampleRate: number): AnalysisResult;
+/**
+ * Perform complete music analysis with progress reporting.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param onProgress - Progress callback (progress: 0-1, stage: string)
+ * @returns Complete analysis result
+ */
+export declare function analyzeWithProgress(samples: Float32Array, sampleRate: number, onProgress: ProgressCallback): AnalysisResult;
+/**
+ * Perform Harmonic-Percussive Source Separation (HPSS).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param kernelHarmonic - Horizontal median filter size for harmonic (default: 31)
+ * @param kernelPercussive - Vertical median filter size for percussive (default: 31)
+ * @returns Separated harmonic and percussive components
+ */
+export declare function hpss(samples: Float32Array, sampleRate: number, kernelHarmonic?: number, kernelPercussive?: number): HpssResult;
+/**
+ * Extract harmonic component from audio.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @returns Harmonic component
+ */
+export declare function harmonic(samples: Float32Array, sampleRate: number): Float32Array;
+/**
+ * Extract percussive component from audio.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @returns Percussive component
+ */
+export declare function percussive(samples: Float32Array, sampleRate: number): Float32Array;
+/**
+ * Time-stretch audio without changing pitch.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param rate - Time stretch rate (0.5 = double duration, 2.0 = half duration)
+ * @returns Time-stretched audio
+ */
+export declare function timeStretch(samples: Float32Array, sampleRate: number, rate: number): Float32Array;
+/**
+ * Pitch-shift audio without changing duration.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param semitones - Pitch shift in semitones (+12 = one octave up, -12 = one octave down)
+ * @returns Pitch-shifted audio
+ */
+export declare function pitchShift(samples: Float32Array, sampleRate: number, semitones: number): Float32Array;
+/**
+ * Normalize audio to target peak level.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param targetDb - Target peak level in dB (default: 0 dB = full scale)
+ * @returns Normalized audio
+ */
+export declare function normalize(samples: Float32Array, sampleRate: number, targetDb?: number): Float32Array;
+/**
+ * Trim silence from beginning and end of audio.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param thresholdDb - Silence threshold in dB (default: -60 dB)
+ * @returns Trimmed audio
+ */
+export declare function trim(samples: Float32Array, sampleRate: number, thresholdDb?: number): Float32Array;
+/**
+ * Compute Short-Time Fourier Transform (STFT).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @returns STFT result with magnitude and power spectrograms
+ */
+export declare function stft(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number): StftResult;
+/**
+ * Compute STFT and return magnitude in decibels.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @returns STFT result with dB values
+ */
+export declare function stftDb(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number): {
+    nBins: number;
+    nFrames: number;
+    db: Float32Array;
+};
+/**
+ * Compute Mel spectrogram.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param nMels - Number of Mel bands (default: 128)
+ * @returns Mel spectrogram result
+ */
+export declare function melSpectrogram(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number, nMels?: number): MelSpectrogramResult;
+/**
+ * Compute MFCC (Mel-Frequency Cepstral Coefficients).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param nMels - Number of Mel bands (default: 128)
+ * @param nMfcc - Number of MFCC coefficients (default: 13)
+ * @returns MFCC result
+ */
+export declare function mfcc(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number, nMels?: number, nMfcc?: number): MfccResult;
+/**
+ * Compute chromagram (pitch class distribution).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @returns Chroma features result
+ */
+export declare function chroma(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number): ChromaResult;
+/**
+ * Compute spectral centroid (center of mass of spectrum).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @returns Spectral centroid in Hz for each frame
+ */
+export declare function spectralCentroid(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number): Float32Array;
+/**
+ * Compute spectral bandwidth.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @returns Spectral bandwidth in Hz for each frame
+ */
+export declare function spectralBandwidth(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number): Float32Array;
+/**
+ * Compute spectral rolloff frequency.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param rollPercent - Percentage threshold (default: 0.85)
+ * @returns Rolloff frequency in Hz for each frame
+ */
+export declare function spectralRolloff(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number, rollPercent?: number): Float32Array;
+/**
+ * Compute spectral flatness.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param nFft - FFT size (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @returns Spectral flatness for each frame (0 = tonal, 1 = noise-like)
+ */
+export declare function spectralFlatness(samples: Float32Array, sampleRate: number, nFft?: number, hopLength?: number): Float32Array;
+/**
+ * Compute zero crossing rate.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param frameLength - Frame length (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @returns Zero crossing rate for each frame
+ */
+export declare function zeroCrossingRate(samples: Float32Array, sampleRate: number, frameLength?: number, hopLength?: number): Float32Array;
+/**
+ * Compute RMS energy.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param frameLength - Frame length (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @returns RMS energy for each frame
+ */
+export declare function rmsEnergy(samples: Float32Array, sampleRate: number, frameLength?: number, hopLength?: number): Float32Array;
+/**
+ * Detect pitch using YIN algorithm.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param frameLength - Frame length (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param fmin - Minimum frequency in Hz (default: 65)
+ * @param fmax - Maximum frequency in Hz (default: 2093)
+ * @param threshold - YIN threshold (default: 0.3)
+ * @returns Pitch detection result
+ */
+export declare function pitchYin(samples: Float32Array, sampleRate: number, frameLength?: number, hopLength?: number, fmin?: number, fmax?: number, threshold?: number): PitchResult;
+/**
+ * Detect pitch using pYIN algorithm (probabilistic YIN with HMM smoothing).
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param sampleRate - Sample rate in Hz
+ * @param frameLength - Frame length (default: 2048)
+ * @param hopLength - Hop length (default: 512)
+ * @param fmin - Minimum frequency in Hz (default: 65)
+ * @param fmax - Maximum frequency in Hz (default: 2093)
+ * @param threshold - YIN threshold (default: 0.3)
+ * @returns Pitch detection result
+ */
+export declare function pitchPyin(samples: Float32Array, sampleRate: number, frameLength?: number, hopLength?: number, fmin?: number, fmax?: number, threshold?: number): PitchResult;
+/**
+ * Convert frequency in Hz to Mel scale.
+ *
+ * @param hz - Frequency in Hz
+ * @returns Mel frequency
+ */
+export declare function hzToMel(hz: number): number;
+/**
+ * Convert Mel scale to frequency in Hz.
+ *
+ * @param mel - Mel frequency
+ * @returns Frequency in Hz
+ */
+export declare function melToHz(mel: number): number;
+/**
+ * Convert frequency in Hz to MIDI note number.
+ *
+ * @param hz - Frequency in Hz
+ * @returns MIDI note number (A4 = 440 Hz = 69)
+ */
+export declare function hzToMidi(hz: number): number;
+/**
+ * Convert MIDI note number to frequency in Hz.
+ *
+ * @param midi - MIDI note number
+ * @returns Frequency in Hz
+ */
+export declare function midiToHz(midi: number): number;
+/**
+ * Convert frequency in Hz to note name.
+ *
+ * @param hz - Frequency in Hz
+ * @returns Note name (e.g., "A4", "C#5")
+ */
+export declare function hzToNote(hz: number): string;
+/**
+ * Convert note name to frequency in Hz.
+ *
+ * @param note - Note name (e.g., "A4", "C#5")
+ * @returns Frequency in Hz
+ */
+export declare function noteToHz(note: string): number;
+/**
+ * Convert frame index to time in seconds.
+ *
+ * @param frames - Frame index
+ * @param sr - Sample rate in Hz
+ * @param hopLength - Hop length in samples
+ * @returns Time in seconds
+ */
+export declare function framesToTime(frames: number, sr: number, hopLength: number): number;
+/**
+ * Convert time in seconds to frame index.
+ *
+ * @param time - Time in seconds
+ * @param sr - Sample rate in Hz
+ * @param hopLength - Hop length in samples
+ * @returns Frame index
+ */
+export declare function timeToFrames(time: number, sr: number, hopLength: number): number;
+/**
+ * Resample audio to a different sample rate.
+ *
+ * @param samples - Audio samples (mono, float32)
+ * @param srcSr - Source sample rate in Hz
+ * @param targetSr - Target sample rate in Hz
+ * @returns Resampled audio
+ */
+export declare function resample(samples: Float32Array, srcSr: number, targetSr: number): Float32Array;
+/**
+ * Wrapper around audio data that exposes all analysis and feature functions as instance methods.
+ *
+ * @example
+ * ```typescript
+ * import { init, Audio } from '@libraz/sonare';
+ *
+ * await init();
+ *
+ * const audio = Audio.fromBuffer(samples, 44100);
+ * console.log('BPM:', audio.detectBpm());
+ * console.log('Key:', audio.detectKey().name);
+ *
+ * const mel = audio.melSpectrogram();
+ * ```
+ */
+export declare class Audio {
+    private _samples;
+    private _sampleRate;
+    private constructor();
+    /** Create an Audio instance from raw sample data. */
+    static fromBuffer(samples: Float32Array, sampleRate: number): Audio;
+    /** The raw audio samples. */
+    get data(): Float32Array;
+    /** Number of samples. */
+    get length(): number;
+    /** Sample rate in Hz. */
+    get sampleRate(): number;
+    /** Duration in seconds. */
+    get duration(): number;
+    detectBpm(): number;
+    detectKey(): Key;
+    detectOnsets(): Float32Array;
+    detectBeats(): Float32Array;
+    analyze(): AnalysisResult;
+    analyzeWithProgress(onProgress: ProgressCallback): AnalysisResult;
+    hpss(kernelHarmonic?: number, kernelPercussive?: number): HpssResult;
+    harmonic(): Float32Array;
+    percussive(): Float32Array;
+    timeStretch(rate: number): Float32Array;
+    pitchShift(semitones: number): Float32Array;
+    normalize(targetDb?: number): Float32Array;
+    trim(thresholdDb?: number): Float32Array;
+    stft(nFft?: number, hopLength?: number): StftResult;
+    stftDb(nFft?: number, hopLength?: number): {
+        nBins: number;
+        nFrames: number;
+        db: Float32Array;
+    };
+    melSpectrogram(nFft?: number, hopLength?: number, nMels?: number): MelSpectrogramResult;
+    mfcc(nFft?: number, hopLength?: number, nMels?: number, nMfcc?: number): MfccResult;
+    chroma(nFft?: number, hopLength?: number): ChromaResult;
+    spectralCentroid(nFft?: number, hopLength?: number): Float32Array;
+    spectralBandwidth(nFft?: number, hopLength?: number): Float32Array;
+    spectralRolloff(nFft?: number, hopLength?: number, rollPercent?: number): Float32Array;
+    spectralFlatness(nFft?: number, hopLength?: number): Float32Array;
+    zeroCrossingRate(frameLength?: number, hopLength?: number): Float32Array;
+    rmsEnergy(frameLength?: number, hopLength?: number): Float32Array;
+    pitchYin(frameLength?: number, hopLength?: number, fmin?: number, fmax?: number, threshold?: number): PitchResult;
+    pitchPyin(frameLength?: number, hopLength?: number, fmin?: number, fmax?: number, threshold?: number): PitchResult;
+    resample(targetSr: number): Float32Array;
+}
+/**
+ * A detected chord change in the progression
+ */
+export interface ChordChange {
+    root: PitchClass;
+    quality: ChordQuality;
+    startTime: number;
+    confidence: number;
+}
+/**
+ * A chord detected at bar boundary (beat-synchronized)
+ */
+export interface BarChord {
+    barIndex: number;
+    root: PitchClass;
+    quality: ChordQuality;
+    startTime: number;
+    confidence: number;
+}
+/**
+ * Pattern score for known chord progressions
+ */
+export interface PatternScore {
+    name: string;
+    score: number;
+}
+/**
+ * Progressive estimation results for BPM, Key, and Chord
+ */
+export interface ProgressiveEstimate {
+    bpm: number;
+    bpmConfidence: number;
+    bpmCandidateCount: number;
+    key: PitchClass;
+    keyMinor: boolean;
+    keyConfidence: number;
+    chordRoot: PitchClass;
+    chordQuality: ChordQuality;
+    chordConfidence: number;
+    chordProgression: ChordChange[];
+    barChordProgression: BarChord[];
+    currentBar: number;
+    barDuration: number;
+    votedPattern: BarChord[];
+    patternLength: number;
+    detectedPatternName: string;
+    detectedPatternScore: number;
+    allPatternScores: PatternScore[];
+    accumulatedSeconds: number;
+    usedFrames: number;
+    updated: boolean;
+}
+/**
+ * Statistics and current state of the analyzer
+ */
+export interface AnalyzerStats {
+    totalFrames: number;
+    totalSamples: number;
+    durationSeconds: number;
+    estimate: ProgressiveEstimate;
+}
+/**
+ * Frame buffer with analysis results
+ */
+export interface FrameBuffer {
+    nFrames: number;
+    timestamps: Float32Array;
+    mel: Float32Array;
+    chroma: Float32Array;
+    onsetStrength: Float32Array;
+    rmsEnergy: Float32Array;
+    spectralCentroid: Float32Array;
+    spectralFlatness: Float32Array;
+    chordRoot: Int32Array;
+    chordQuality: Int32Array;
+    chordConfidence: Float32Array;
+}
+/**
+ * Configuration for StreamAnalyzer
+ */
+export interface StreamConfig {
+    sampleRate: number;
+    nFft?: number;
+    hopLength?: number;
+    nMels?: number;
+    computeMel?: boolean;
+    computeChroma?: boolean;
+    computeOnset?: boolean;
+    emitEveryNFrames?: number;
+}
+/**
+ * Real-time streaming audio analyzer.
+ *
+ * @example
+ * ```typescript
+ * import { init, StreamAnalyzer } from '@libraz/sonare';
+ *
+ * await init();
+ *
+ * const analyzer = new StreamAnalyzer({ sampleRate: 44100 });
+ *
+ * // In audio processing callback
+ * analyzer.process(samples);
+ *
+ * // Get current analysis state
+ * const stats = analyzer.stats();
+ * console.log('BPM:', stats.estimate.bpm);
+ * console.log('Key:', stats.estimate.key);
+ * console.log('Chord progression:', stats.estimate.chordProgression);
+ * ```
+ */
+export declare class StreamAnalyzer {
+    private analyzer;
+    /**
+     * Create a new StreamAnalyzer.
+     *
+     * @param config - Configuration options
+     */
+    constructor(config: StreamConfig);
+    /**
+     * Process audio samples.
+     *
+     * @param samples - Audio samples (mono, float32)
+     */
+    process(samples: Float32Array): void;
+    /**
+     * Process audio samples with explicit sample offset.
+     *
+     * @param samples - Audio samples (mono, float32)
+     * @param sampleOffset - Cumulative sample count at start of this chunk
+     */
+    processWithOffset(samples: Float32Array, sampleOffset: number): void;
+    /**
+     * Get the number of frames available to read.
+     */
+    availableFrames(): number;
+    /**
+     * Read processed frames as Structure of Arrays.
+     *
+     * @param maxFrames - Maximum number of frames to read
+     * @returns Frame buffer with analysis results
+     */
+    readFrames(maxFrames: number): FrameBuffer;
+    /**
+     * Reset the analyzer state.
+     *
+     * @param baseSampleOffset - Starting sample offset (default 0)
+     */
+    reset(baseSampleOffset?: number): void;
+    /**
+     * Get current statistics and progressive estimates.
+     *
+     * @returns Analyzer statistics including BPM, key, and chord progression
+     */
+    stats(): AnalyzerStats;
+    /**
+     * Get total frames processed.
+     */
+    frameCount(): number;
+    /**
+     * Get current time position in seconds.
+     */
+    currentTime(): number;
+    /**
+     * Get the sample rate.
+     */
+    sampleRate(): number;
+    /**
+     * Set the expected total duration for pattern lock timing.
+     *
+     * @param durationSeconds - Total duration in seconds
+     */
+    setExpectedDuration(durationSeconds: number): void;
+    /**
+     * Set normalization gain for loud/compressed audio.
+     *
+     * @param gain - Gain factor to apply (e.g., 0.5 for -6dB reduction)
+     */
+    setNormalizationGain(gain: number): void;
+    /**
+     * Set tuning reference frequency for non-standard tuning.
+     *
+     * @param refHz - Reference frequency for A4 (default 440 Hz)
+     * @example
+     * // If audio is 1 semitone sharp (A4 = 466.16 Hz)
+     * analyzer.setTuningRefHz(466.16);
+     * // If audio is 1 semitone flat (A4 = 415.30 Hz)
+     * analyzer.setTuningRefHz(415.30);
+     */
+    setTuningRefHz(refHz: number): void;
+    /**
+     * Release resources. Call when done using the analyzer.
+     */
+    dispose(): void;
+}
+export { PitchClass as Pitch };
+//# sourceMappingURL=index.d.ts.map