@libraz/libsonare 1.2.1 → 1.2.2

package/src/wasm_types.ts

@@ -1,1259 +0,0 @@
-export type ProgressCallback = (progress: number, stage: string) => void;
-export type TempogramMode = 'autocorrelation' | 'auto' | 'ac' | 'cosine' | 0 | 1;
-
-export interface WasmKeyResult {
-  root: number;
-  mode: number;
-  confidence: number;
-  name: string;
-  shortName: string;
-}
-
-export interface WasmKeyCandidateResult {
-  key: WasmKeyResult;
-  correlation: number;
-}
-
-export interface WasmBeatResult {
-  time: number;
-  strength: number;
-}
-
-export interface WasmChordResult {
-  root: number;
-  bass: number;
-  quality: number;
-  start: number;
-  end: number;
-  confidence: number;
-  name: string;
-}
-
-export interface WasmSectionResult {
-  type: number;
-  start: number;
-  end: number;
-  energyLevel: number;
-  confidence: number;
-  name: string;
-}
-
-export interface WasmTimbreResult {
-  brightness: number;
-  warmth: number;
-  density: number;
-  roughness: number;
-  complexity: number;
-}
-
-export interface WasmDynamicsResult {
-  dynamicRangeDb: number;
-  loudnessRangeDb: number;
-  crestFactor: number;
-  isCompressed: boolean;
-}
-
-export interface WasmRhythmResult {
-  syncopation: number;
-  grooveType: string;
-  patternRegularity: number;
-}
-
-export interface WasmTimeSignatureResult {
-  numerator: number;
-  denominator: number;
-  confidence: number;
-}
-
-export interface WasmAnalysisResult {
-  bpm: number;
-  bpmConfidence: number;
-  key: WasmKeyResult;
-  timeSignature: WasmTimeSignatureResult;
-  beats: WasmBeatResult[];
-  chords: WasmChordResult[];
-  sections: WasmSectionResult[];
-  timbre: WasmTimbreResult;
-  dynamics: WasmDynamicsResult;
-  rhythm: WasmRhythmResult;
-  form: string;
-}
-
-export interface WasmChordAnalysisResult {
-  chords: WasmChordResult[];
-}
-
-export interface WasmAcousticResult {
-  rt60: number;
-  edt: number;
-  c50: number;
-  c80: number;
-  d50: number;
-  rt60Bands: Float32Array;
-  edtBands: Float32Array;
-  c50Bands: Float32Array;
-  c80Bands: Float32Array;
-  confidence: number;
-  isBlind: boolean;
-}
-
-export interface WasmHpssResult {
-  harmonic: Float32Array;
-  percussive: Float32Array;
-  sampleRate: number;
-}
-
-export interface WasmMasteringResult {
-  samples: Float32Array;
-  sampleRate: number;
-  inputLufs: number;
-  outputLufs: number;
-  appliedGainDb: number;
-  latencySamples?: number;
-}
-
-export interface WasmMasteringChainResult extends WasmMasteringResult {
-  stages: string[];
-}
-
-export interface WasmMasteringStereoResult {
-  left: Float32Array;
-  right: Float32Array;
-  sampleRate: number;
-  inputLufs: number;
-  outputLufs: number;
-  appliedGainDb: number;
-  latencySamples: number;
-}
-
-export interface WasmMasteringStereoChainResult {
-  left: Float32Array;
-  right: Float32Array;
-  sampleRate: number;
-  inputLufs: number;
-  outputLufs: number;
-  appliedGainDb: number;
-  stages: string[];
-}
-
-export interface WasmMixMeterSnapshot {
-  peakDbL: number;
-  peakDbR: number;
-  rmsDbL: number;
-  rmsDbR: number;
-  correlation: number;
-  monoCompatWidth: number;
-  monoCompatPeak: number;
-  monoCompatSideRms: number;
-  likelyMonoCompatible: boolean;
-  momentaryLufs: number;
-  shortTermLufs: number;
-  integratedLufs: number;
-  gainReductionDb: number;
-  truePeakDbL: number;
-  truePeakDbR: number;
-  maxTruePeakDb: number;
-  seq: number;
-}
-
-export interface WasmMixResult {
-  left: Float32Array;
-  right: Float32Array;
-  sampleRate: number;
-  meters: WasmMixMeterSnapshot[];
-}
-
-export interface WasmStftResult {
-  nBins: number;
-  nFrames: number;
-  nFft: number;
-  hopLength: number;
-  sampleRate: number;
-  magnitude: Float32Array;
-  power: Float32Array;
-}
-
-export interface WasmStftDbResult {
-  nBins: number;
-  nFrames: number;
-  db: Float32Array;
-}
-
-export interface WasmMelResult {
-  nMels: number;
-  nFrames: number;
-  sampleRate: number;
-  hopLength: number;
-  power: Float32Array;
-  db: Float32Array;
-}
-
-export interface WasmMfccResult {
-  nMfcc: number;
-  nFrames: number;
-  coefficients: Float32Array;
-}
-
-export interface WasmStftPowerResult {
-  nBins: number;
-  nFrames: number;
-  power: Float32Array;
-}
-
-export interface WasmMelPowerResult {
-  nMels: number;
-  nFrames: number;
-  power: Float32Array;
-}
-
-export interface WasmChromaResult {
-  nChroma: number;
-  nFrames: number;
-  sampleRate: number;
-  hopLength: number;
-  features: Float32Array;
-  meanEnergy: number[];
-}
-
-export interface WasmPitchResult {
-  f0: Float32Array;
-  voicedProb: Float32Array;
-  voicedFlag: boolean[];
-  nFrames: number;
-  medianF0: number;
-  meanF0: number;
-}
-
-export interface WasmTrimResult {
-  audio: Float32Array;
-  startSample: number;
-  endSample: number;
-}
-
-export interface WasmFrameResult {
-  nFrames: number;
-  frames: Float32Array;
-}
-
-export interface WasmTempogramResult {
-  nFrames: number;
-  winLength: number;
-  data: Float32Array;
-}
-
-export interface WasmCyclicTempogramResult {
-  nFrames: number;
-  nBins: number;
-  data: Float32Array;
-}
-
-export interface WasmFourierTempogramResult {
-  nBins: number;
-  nFrames: number;
-  data: Float32Array;
-}
-
-export interface WasmNnlsChromaResult {
-  nChroma: number;
-  nFrames: number;
-  data: Float32Array;
-}
-
-export interface WasmMelodyPoint {
-  time: number;
-  frequency: number;
-  confidence: number;
-}
-
-export interface WasmMelodyResult {
-  points: WasmMelodyPoint[];
-  pitchRangeOctaves: number;
-  pitchStability: number;
-  meanFrequency: number;
-  vibratoRate: number;
-}
-
-export interface WasmCqtResult {
-  nBins: number;
-  nFrames: number;
-  hopLength: number;
-  sampleRate: number;
-  magnitude: Float32Array;
-  frequencies: Float32Array;
-}
-
-export interface WasmLufsResult {
-  integratedLufs: number;
-  momentaryLufs: number;
-  shortTermLufs: number;
-  loudnessRange: number;
-}
-
-export interface WasmChordChange {
-  root: number;
-  quality: number;
-  startTime: number;
-  confidence: number;
-}
-
-export interface WasmBarChord {
-  barIndex: number;
-  root: number;
-  quality: number;
-  startTime: number;
-  confidence: number;
-}
-
-export interface WasmPatternScore {
-  name: string;
-  score: number;
-}
-
-export interface WasmProgressiveEstimate {
-  bpm: number;
-  bpmConfidence: number;
-  bpmCandidateCount: number;
-  key: number;
-  keyMinor: boolean;
-  keyConfidence: number;
-  chordRoot: number;
-  chordQuality: number;
-  chordConfidence: number;
-  chordStartTime: number;
-  chordProgression: WasmChordChange[];
-  barChordProgression: WasmBarChord[];
-  currentBar: number;
-  barDuration: number;
-  votedPattern: WasmBarChord[];
-  patternLength: number;
-  detectedPatternName: string;
-  detectedPatternScore: number;
-  allPatternScores: WasmPatternScore[];
-  accumulatedSeconds: number;
-  usedFrames: number;
-  updated: boolean;
-}
-
-export interface WasmAnalyzerStats {
-  totalFrames: number;
-  totalSamples: number;
-  durationSeconds: number;
-  estimate: WasmProgressiveEstimate;
-}
-
-export interface WasmFrameBuffer {
-  nFrames: number;
-  timestamps: Float32Array;
-  mel: Float32Array;
-  chroma: Float32Array;
-  onsetStrength: Float32Array;
-  rmsEnergy: Float32Array;
-  spectralCentroid: Float32Array;
-  spectralFlatness: Float32Array;
-  chordRoot: Int32Array;
-  chordQuality: Int32Array;
-  chordConfidence: Float32Array;
-}
-
-export interface WasmStreamFramesU8 {
-  nFrames: number;
-  nMels: number;
-  timestamps: Float32Array;
-  mel: Uint8Array;
-  chroma: Uint8Array;
-  onsetStrength: Uint8Array;
-  rmsEnergy: Uint8Array;
-  spectralCentroid: Uint8Array;
-  spectralFlatness: Uint8Array;
-}
-
-export interface WasmStreamFramesI16 {
-  nFrames: number;
-  nMels: number;
-  timestamps: Float32Array;
-  mel: Int16Array;
-  chroma: Int16Array;
-  onsetStrength: Int16Array;
-  rmsEnergy: Int16Array;
-  spectralCentroid: Int16Array;
-  spectralFlatness: Int16Array;
-}
-
-export interface WasmStreamingMasteringChain {
-  prepare: (sampleRate: number, maxBlockSize: number, numChannels: number) => void;
-  processMono: (samples: Float32Array) => Float32Array;
-  processStereo: (
-    left: Float32Array,
-    right: Float32Array,
-  ) => { left: Float32Array; right: Float32Array };
-  reset: () => void;
-  latencySamples: () => number;
-  stageNames: () => string[];
-  delete: () => void;
-}
-
-export interface WasmEqSpectrumSnapshot {
-  preLeft: Float32Array;
-  preRight: Float32Array;
-  postLeft: Float32Array;
-  postRight: Float32Array;
-  bandGainDb: Float32Array;
-  profileDb: Float32Array;
-  lastAutoGainDb: number;
-  seq: number;
-}
-
-export interface WasmStreamingEqualizer {
-  setBand: (index: number, band: Record<string, unknown>) => void;
-  clear: () => void;
-  setPhaseMode: (mode: number) => void;
-  setAutoGain: (enabled: boolean) => void;
-  setGainScale: (scale: number) => void;
-  setOutputGainDb: (gainDb: number) => void;
-  setOutputPan: (pan: number) => void;
-  setSidechainMono: (samples: Float32Array) => void;
-  setSidechainStereo: (left: Float32Array, right: Float32Array) => void;
-  clearSidechain: () => void;
-  lastAutoGainDb: () => number;
-  latencySamples: () => number;
-  processMono: (samples: Float32Array) => Float32Array;
-  processStereo: (
-    left: Float32Array,
-    right: Float32Array,
-  ) => { left: Float32Array; right: Float32Array };
-  spectrum: () => WasmEqSpectrumSnapshot;
-  match: (source: Float32Array, reference: Float32Array, options: Record<string, unknown>) => void;
-  delete: () => void;
-}
-
-export interface WasmStreamingRetune {
-  prepare: (sampleRate: number, maxBlockSize: number) => void;
-  reset: () => void;
-  setConfig: (config: Record<string, unknown>) => void;
-  config: () => { semitones: number; mix: number; grainSize: number };
-  grainSize: () => number;
-  processMono: (samples: Float32Array) => Float32Array;
-  delete: () => void;
-}
-
-export interface WasmEngineClip {
-  id?: number;
-  channels: Float32Array[];
-  startPpq: number;
-  lengthSamples?: number;
-  clipOffsetSamples?: number;
-  loop?: boolean;
-  gain?: number;
-  fadeInSamples?: number;
-  fadeOutSamples?: number;
-}
-
-export interface WasmEngineParameterInfo {
-  id: number;
-  name: string;
-  unit: string;
-  minValue: number;
-  maxValue: number;
-  defaultValue: number;
-  rtSafe: boolean;
-  defaultCurve: number;
-}
-
-export interface WasmEngineAutomationPoint {
-  ppq: number;
-  value: number;
-  curveToNext?: number;
-}
-
-export interface WasmEngineMarker {
-  id: number;
-  ppq: number;
-  name?: string;
-}
-
-export interface WasmEngineMetronomeConfig {
-  enabled: boolean;
-  beatGain?: number;
-  accentGain?: number;
-  clickSamples?: number;
-}
-
-export interface WasmEngineGraphNode {
-  id: string;
-  type?: number;
-  gainDb?: number;
-  numPorts?: number;
-}
-
-export interface WasmEngineGraphConnection {
-  sourceNode: string;
-  sourcePort: number;
-  destNode: string;
-  destPort: number;
-  mix?: number;
-}
-
-export interface WasmEngineGraphParameterBinding {
-  paramId: number;
-  nodeId: string;
-}
-
-export interface WasmEngineGraphSpec {
-  nodes: WasmEngineGraphNode[];
-  connections: WasmEngineGraphConnection[];
-  inputNode: string;
-  outputNode: string;
-  numChannels: number;
-  parameterBindings?: WasmEngineGraphParameterBinding[];
-}
-
-export interface WasmEngineTelemetry {
-  type: number;
-  error: number;
-  renderFrame: number;
-  timelineSample: number;
-  audibleTimelineSample: number;
-  graphLatencySamplesQ8: number;
-  value: number;
-}
-
-export interface WasmEngineMeterTelemetry {
-  targetId: number;
-  renderFrame: number;
-  seq: number;
-  peakDbL: number;
-  peakDbR: number;
-  rmsDbL: number;
-  rmsDbR: number;
-  truePeakDbL: number;
-  truePeakDbR: number;
-  maxTruePeakDb: number;
-  correlation: number;
-  monoCompatWidth: number;
-  momentaryLufs: number;
-  shortTermLufs: number;
-  integratedLufs: number;
-  gainReductionDb: number;
-  droppedRecords: number;
-}
-
-export interface WasmEngineCaptureStatus {
-  capturedFrames: number;
-  overflowCount: number;
-  armed: boolean;
-  punchEnabled: boolean;
-}
-
-export interface WasmEngineTransportState {
-  playing: boolean;
-  looping: boolean;
-  renderFrame: number;
-  samplePosition: number;
-  ppq: number;
-  bpm: number;
-  loopStartPpq: number;
-  loopEndPpq: number;
-  sampleRate: number;
-}
-
-export interface WasmEngineBounceOptions {
-  totalFrames: number;
-  blockSize?: number;
-  numChannels?: number;
-  targetSampleRate?: number;
-  sourceSampleRate?: number;
-  normalizeLufs?: boolean;
-  targetLufs?: number;
-  dither?: 0 | 1 | 2 | 3;
-  ditherBits?: number;
-  ditherSeed?: number;
-}
-
-export interface WasmEngineBounceResult {
-  interleaved: Float32Array;
-  frames: number;
-  numChannels: number;
-  sampleRate: number;
-  integratedLufs: number;
-}
-
-export interface WasmEngineFreezeOptions {
-  totalFrames: number;
-  blockSize?: number;
-  numChannels?: number;
-  clipId?: number;
-  startPpq?: number;
-  gain?: number;
-}
-
-export interface WasmEngineFreezeResult {
-  clipId: number;
-  frames: number;
-  numChannels: number;
-}
-
-export interface WasmEngineProcessWithMonitorResult {
-  output: Float32Array[];
-  monitor: Float32Array[];
-}
-
-export interface WasmRealtimeEngine {
-  prepare: (
-    sampleRate: number,
-    maxBlockSize: number,
-    commandCapacity: number,
-    telemetryCapacity: number,
-  ) => void;
-  setParameter: (paramId: number, value: number, renderFrame: number) => void;
-  setParameterSmoothed: (paramId: number, value: number, renderFrame: number) => void;
-  getTransportState: () => WasmEngineTransportState;
-  play: (renderFrame: number) => void;
-  stop: (renderFrame: number) => void;
-  seekSample: (timelineSample: number, renderFrame: number) => void;
-  seekPpq: (ppq: number, renderFrame: number) => void;
-  setTempo: (bpm: number) => void;
-  setTimeSignature: (numerator: number, denominator: number) => void;
-  setLoop: (startPpq: number, endPpq: number, enabled: boolean) => void;
-  addParameter: (info: WasmEngineParameterInfo) => void;
-  parameterCount: () => number;
-  parameterInfoByIndex: (index: number) => WasmEngineParameterInfo;
-  parameterInfo: (id: number) => WasmEngineParameterInfo;
-  setAutomationLane: (paramId: number, points: WasmEngineAutomationPoint[]) => void;
-  automationLaneCount: () => number;
-  setMarkers: (markers: WasmEngineMarker[]) => void;
-  markerCount: () => number;
-  markerByIndex: (index: number) => WasmEngineMarker;
-  marker: (id: number) => WasmEngineMarker;
-  seekMarker: (id: number, renderFrame: number) => void;
-  setLoopFromMarkers: (startMarkerId: number, endMarkerId: number) => void;
-  setMetronome: (config: WasmEngineMetronomeConfig) => void;
-  metronome: () => Required<WasmEngineMetronomeConfig>;
-  countInEndSample: (startSample: number, bars: number) => number;
-  setGraph: (spec: WasmEngineGraphSpec) => void;
-  graphNodeCount: () => number;
-  graphConnectionCount: () => number;
-  setClips: (clips: WasmEngineClip[]) => void;
-  clipCount: () => number;
-  setCaptureBuffer: (numChannels: number, capacityFrames: number) => void;
-  armCapture: (armed: boolean) => void;
-  setCapturePunch: (startSample: number, endSample: number, enabled: boolean) => void;
-  resetCapture: () => void;
-  captureStatus: () => WasmEngineCaptureStatus;
-  capturedAudio: () => Float32Array[];
-  process: (channels: Float32Array[]) => Float32Array[];
-  processWithMonitor: (channels: Float32Array[]) => WasmEngineProcessWithMonitorResult;
-  renderOffline: (channels: Float32Array[], blockSize: number) => Float32Array[];
-  bounceOffline: (options: WasmEngineBounceOptions) => WasmEngineBounceResult;
-  freezeOffline: (options: WasmEngineFreezeOptions) => WasmEngineFreezeResult;
-  drainTelemetry: (maxRecords: number) => WasmEngineTelemetry[];
-  drainMeterTelemetry: (maxRecords: number) => WasmEngineMeterTelemetry[];
-  delete: () => void;
-}
-
-export interface WasmMixer {
-  compile: () => void;
-  processStereo: (
-    leftChannels: Float32Array[],
-    rightChannels: Float32Array[],
-  ) => { left: Float32Array; right: Float32Array; sampleRate: number };
-  processStereoInto: (
-    leftChannels: Float32Array[],
-    rightChannels: Float32Array[],
-    outLeft: Float32Array,
-    outRight: Float32Array,
-  ) => void;
-  inputLeftView: (index: number) => Float32Array;
-  inputRightView: (index: number) => Float32Array;
-  outputLeftView: () => Float32Array;
-  outputRightView: () => Float32Array;
-  processPreparedStereo: (numSamples: number) => void;
-  stripCount: () => number;
-  scheduleInsertAutomation: (
-    stripIndex: number,
-    insertIndex: number,
-    paramId: number,
-    samplePos: number,
-    value: number,
-    curve: number,
-  ) => void;
-  stripById: (id: string) => number;
-  setSoloed: (stripIndex: number, soloed: boolean) => void;
-  setSoloSafe: (stripIndex: number, soloSafe: boolean) => void;
-  setPolarityInvert: (stripIndex: number, invertLeft: boolean, invertRight: boolean) => void;
-  setPanLaw: (stripIndex: number, panLaw: number) => void;
-  setChannelDelaySamples: (stripIndex: number, delaySamples: number) => void;
-  setVcaOffsetDb: (stripIndex: number, offsetDb: number) => void;
-  setDualPan: (stripIndex: number, leftPan: number, rightPan: number) => void;
-  addSend: (
-    stripIndex: number,
-    id: string,
-    destinationBusId: string,
-    sendDb: number,
-    timing: number,
-  ) => number;
-  setSendDb: (stripIndex: number, sendIndex: number, sendDb: number) => void;
-  meterTap: (stripIndex: number, tap: number) => WasmMixMeterSnapshot;
-  stripMeter: (stripIndex: number, tap: number) => WasmMixMeterSnapshot;
-  scheduleFaderAutomation: (
-    stripIndex: number,
-    samplePos: number,
-    faderDb: number,
-    curve: number,
-  ) => void;
-  schedulePanAutomation: (
-    stripIndex: number,
-    samplePos: number,
-    pan: number,
-    curve: number,
-  ) => void;
-  scheduleWidthAutomation: (
-    stripIndex: number,
-    samplePos: number,
-    width: number,
-    curve: number,
-  ) => void;
-  scheduleSendAutomation: (
-    stripIndex: number,
-    sendIndex: number,
-    samplePos: number,
-    db: number,
-    curve: number,
-  ) => void;
-  readGoniometerLatest: (stripIndex: number, maxPoints: number) => WasmGoniometerPoint[];
-  addBus: (id: string, role: string) => void;
-  removeBus: (id: string) => void;
-  busCount: () => number;
-  addVcaGroup: (id: string, gainDb: number, members: string[]) => void;
-  removeVcaGroup: (id: string) => void;
-  vcaGroupCount: () => number;
-  toSceneJson: () => string;
-  delete: () => void;
-}
-
-export interface WasmGoniometerPoint {
-  left: number;
-  right: number;
-}
-
-export interface WasmStreamAnalyzer {
-  process: (samples: Float32Array) => void;
-  processWithOffset: (samples: Float32Array, sampleOffset: number) => void;
-  availableFrames: () => number;
-  readFramesSoa: (maxFrames: number) => WasmFrameBuffer;
-  readFramesU8: (maxFrames: number) => WasmStreamFramesU8;
-  readFramesI16: (maxFrames: number) => WasmStreamFramesI16;
-  reset: (baseSampleOffset?: number) => void;
-  stats: () => WasmAnalyzerStats;
-  frameCount: () => number;
-  currentTime: () => number;
-  sampleRate: () => number;
-  setExpectedDuration: (durationSeconds: number) => void;
-  setNormalizationGain: (gain: number) => void;
-  setTuningRefHz: (refHz: number) => void;
-  delete: () => void;
-}
-
-export interface SonareModule {
-  detectBpm: (samples: Float32Array, sampleRate: number) => number;
-  detectKey: (samples: Float32Array, sampleRate: number) => WasmKeyResult;
-  _detectKeyWithOptions: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    useHpss: boolean,
-    loudnessWeighted: boolean,
-    highPassHz: number,
-    modes: number[],
-    profileType: number,
-    genreHint: string,
-  ) => WasmKeyResult;
-  _detectKeyCandidates: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    useHpss: boolean,
-    loudnessWeighted: boolean,
-    highPassHz: number,
-    modes: number[],
-    profileType: number,
-    genreHint: string,
-  ) => WasmKeyCandidateResult[];
-  detectOnsets: (samples: Float32Array, sampleRate: number) => Float32Array;
-  detectBeats: (samples: Float32Array, sampleRate: number) => Float32Array;
-  detectDownbeats: (samples: Float32Array, sampleRate: number) => Float32Array;
-  detectChords: (
-    samples: Float32Array,
-    sampleRate: number,
-    minDuration: number,
-    smoothingWindow: number,
-    threshold: number,
-    useTriadsOnly: boolean,
-    nFft: number,
-    hopLength: number,
-    useBeatSync: boolean,
-    useHmm: boolean,
-    hmmBeamWidth: number,
-    useKeyContext: boolean,
-    keyRoot: number,
-    keyMode: number,
-    detectInversions: boolean,
-    chromaMethod: number,
-  ) => WasmChordAnalysisResult;
-  analyze: (samples: Float32Array, sampleRate: number) => WasmAnalysisResult;
-  analyzeImpulseResponse: (
-    samples: Float32Array,
-    sampleRate: number,
-    nOctaveBands: number,
-  ) => WasmAcousticResult;
-  detectAcoustic: (
-    samples: Float32Array,
-    sampleRate: number,
-    nOctaveBands: number,
-    nThirdOctaveSubbands: number,
-    minDecayDb: number,
-    noiseFloorMarginDb: number,
-  ) => WasmAcousticResult;
-  analyzeWithProgress: (
-    samples: Float32Array,
-    sampleRate: number,
-    progressCallback: ProgressCallback | null,
-  ) => WasmAnalysisResult;
-  version: () => string;
-  engineAbiVersion: () => number;
-
-  hpss: (
-    samples: Float32Array,
-    sampleRate: number,
-    kernelHarmonic: number,
-    kernelPercussive: number,
-  ) => WasmHpssResult;
-  harmonic: (samples: Float32Array, sampleRate: number) => Float32Array;
-  percussive: (samples: Float32Array, sampleRate: number) => Float32Array;
-  timeStretch: (samples: Float32Array, sampleRate: number, rate: number) => Float32Array;
-  pitchShift: (samples: Float32Array, sampleRate: number, semitones: number) => Float32Array;
-  pitchCorrectToMidi: (
-    samples: Float32Array,
-    sampleRate: number,
-    currentMidi: number,
-    targetMidi: number,
-  ) => Float32Array;
-  noteStretch: (
-    samples: Float32Array,
-    sampleRate: number,
-    onsetSample: number,
-    offsetSample: number,
-    stretchRatio: number,
-  ) => Float32Array;
-  voiceChange: (
-    samples: Float32Array,
-    sampleRate: number,
-    pitchSemitones: number,
-    formantFactor: number,
-  ) => Float32Array;
-  normalize: (samples: Float32Array, sampleRate: number, targetDb: number) => Float32Array;
-  mastering: (
-    samples: Float32Array,
-    sampleRate: number,
-    targetLufs: number,
-    ceilingDb: number,
-    truePeakOversample: number,
-  ) => WasmMasteringResult;
-  masteringProcessorNames: () => string[];
-  masteringPairProcessorNames: () => string[];
-  masteringPairAnalysisNames: () => string[];
-  masteringStereoAnalysisNames: () => string[];
-  masteringProcess: (
-    processorName: string,
-    samples: Float32Array,
-    sampleRate: number,
-    params: Record<string, number | boolean>,
-  ) => WasmMasteringResult;
-  masteringProcessStereo: (
-    processorName: string,
-    left: Float32Array,
-    right: Float32Array,
-    sampleRate: number,
-    params: Record<string, number | boolean>,
-  ) => WasmMasteringStereoResult;
-  masteringPairProcess: (
-    processorName: string,
-    source: Float32Array,
-    reference: Float32Array,
-    sampleRate: number,
-    params: Record<string, number | boolean>,
-  ) => WasmMasteringResult;
-  masteringPairAnalyze: (
-    analysisName: string,
-    source: Float32Array,
-    reference: Float32Array,
-    sampleRate: number,
-    params: Record<string, number | boolean>,
-  ) => string;
-  masteringStereoAnalyze: (
-    analysisName: string,
-    left: Float32Array,
-    right: Float32Array,
-    sampleRate: number,
-    params: Record<string, number | boolean>,
-  ) => string;
-  masteringAssistantSuggest: (
-    samples: Float32Array,
-    sampleRate: number,
-    params: Record<string, number | boolean>,
-  ) => string;
-  masteringAudioProfile: (
-    samples: Float32Array,
-    sampleRate: number,
-    params: Record<string, number | boolean>,
-  ) => string;
-  masteringStreamingPreview: (
-    samples: Float32Array,
-    sampleRate: number,
-    platforms: Array<{ name: string; targetLufs: number; ceilingDb: number }>,
-  ) => string;
-  masteringChain: (
-    samples: Float32Array,
-    sampleRate: number,
-    config: Record<string, unknown>,
-  ) => WasmMasteringChainResult;
-  masteringChainStereo: (
-    left: Float32Array,
-    right: Float32Array,
-    sampleRate: number,
-    config: Record<string, unknown>,
-  ) => WasmMasteringStereoChainResult;
-  masteringChainWithProgress: (
-    samples: Float32Array,
-    sampleRate: number,
-    config: Record<string, unknown>,
-    progressCallback: ProgressCallback | null,
-  ) => WasmMasteringChainResult;
-  masteringChainStereoWithProgress: (
-    left: Float32Array,
-    right: Float32Array,
-    sampleRate: number,
-    config: Record<string, unknown>,
-    progressCallback: ProgressCallback | null,
-  ) => WasmMasteringStereoChainResult;
-  masteringPresetNames: () => string[];
-  masterAudio: (
-    presetName: string,
-    samples: Float32Array,
-    sampleRate: number,
-    overrides: Record<string, number | boolean> | null,
-  ) => WasmMasteringChainResult;
-  masterAudioStereo: (
-    presetName: string,
-    left: Float32Array,
-    right: Float32Array,
-    sampleRate: number,
-    overrides: Record<string, number | boolean> | null,
-  ) => WasmMasteringStereoChainResult;
-  mixingScenePresetNames: () => string[];
-  mixingScenePresetJson: (presetName: string) => string;
-  mixStereo: (
-    leftChannels: Float32Array[],
-    rightChannels: Float32Array[],
-    sampleRate: number,
-    options: Record<string, unknown>,
-  ) => WasmMixResult;
-  trim: (samples: Float32Array, sampleRate: number, thresholdDb: number) => Float32Array;
-
-  stft: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-  ) => WasmStftResult;
-  stftDb: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-  ) => WasmStftDbResult;
-
-  melSpectrogram: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    nMels: number,
-  ) => WasmMelResult;
-  mfcc: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    nMels: number,
-    nMfcc: number,
-  ) => WasmMfccResult;
-
-  melToStft: (
-    melPower: Float32Array,
-    nMels: number,
-    nFrames: number,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    fmin: number,
-    fmax: number,
-  ) => WasmStftPowerResult;
-  melToAudio: (
-    melPower: Float32Array,
-    nMels: number,
-    nFrames: number,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    nIter: number,
-    fmin: number,
-    fmax: number,
-  ) => Float32Array;
-  mfccToMel: (
-    mfcc: Float32Array,
-    nMfcc: number,
-    nFrames: number,
-    nMels: number,
-  ) => WasmMelPowerResult;
-  mfccToAudio: (
-    mfcc: Float32Array,
-    nMfcc: number,
-    nFrames: number,
-    nMels: number,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    nIter: number,
-    fmin: number,
-    fmax: number,
-  ) => Float32Array;
-
-  chroma: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-  ) => WasmChromaResult;
-
-  spectralCentroid: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-  ) => Float32Array;
-  spectralBandwidth: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-  ) => Float32Array;
-  spectralRolloff: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    rollPercent: number,
-  ) => Float32Array;
-  spectralFlatness: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-  ) => Float32Array;
-  zeroCrossingRate: (
-    samples: Float32Array,
-    sampleRate: number,
-    frameLength: number,
-    hopLength: number,
-  ) => Float32Array;
-  rmsEnergy: (
-    samples: Float32Array,
-    sampleRate: number,
-    frameLength: number,
-    hopLength: number,
-  ) => Float32Array;
-
-  pitchYin: (
-    samples: Float32Array,
-    sampleRate: number,
-    frameLength: number,
-    hopLength: number,
-    fmin: number,
-    fmax: number,
-    threshold: number,
-  ) => WasmPitchResult;
-  pitchPyin: (
-    samples: Float32Array,
-    sampleRate: number,
-    frameLength: number,
-    hopLength: number,
-    fmin: number,
-    fmax: number,
-    threshold: number,
-  ) => WasmPitchResult;
-
-  hzToMel: (hz: number) => number;
-  melToHz: (mel: number) => number;
-  hzToMidi: (hz: number) => number;
-  midiToHz: (midi: number) => number;
-  hzToNote: (hz: number) => string;
-  noteToHz: (note: string) => number;
-  framesToTime: (frames: number, sr: number, hopLength: number) => number;
-  timeToFrames: (time: number, sr: number, hopLength: number) => number;
-  framesToSamples: (frames: number, hopLength: number, nFft: number) => number;
-  samplesToFrames: (samples: number, hopLength: number, nFft: number) => number;
-  powerToDb: (values: Float32Array, ref: number, amin: number, topDb: number) => Float32Array;
-  amplitudeToDb: (values: Float32Array, ref: number, amin: number, topDb: number) => Float32Array;
-  dbToPower: (values: Float32Array, ref: number) => Float32Array;
-  dbToAmplitude: (values: Float32Array, ref: number) => Float32Array;
-  preemphasis: (samples: Float32Array, coef: number, zi?: number | null) => Float32Array;
-  deemphasis: (samples: Float32Array, coef: number, zi?: number | null) => Float32Array;
-  trimSilence: (
-    samples: Float32Array,
-    topDb: number,
-    frameLength: number,
-    hopLength: number,
-  ) => WasmTrimResult;
-  splitSilence: (
-    samples: Float32Array,
-    topDb: number,
-    frameLength: number,
-    hopLength: number,
-  ) => Int32Array;
-  frameSignal: (samples: Float32Array, frameLength: number, hopLength: number) => WasmFrameResult;
-  padCenter: (values: Float32Array, size: number, padValue: number) => Float32Array;
-  fixLength: (values: Float32Array, size: number, padValue: number) => Float32Array;
-  fixFrames: (frames: Int32Array, xMin: number, xMax: number, pad: boolean) => Int32Array;
-  peakPick: (
-    values: Float32Array,
-    preMax: number,
-    postMax: number,
-    preAvg: number,
-    postAvg: number,
-    delta: number,
-    wait: number,
-  ) => Int32Array;
-  vectorNormalize: (values: Float32Array, normType: number, threshold: number) => Float32Array;
-  pcen: (
-    values: Float32Array,
-    nBins: number,
-    nFrames: number,
-    options?: Record<string, number> | null,
-  ) => Float32Array;
-  tonnetz: (chromagram: Float32Array, nChroma: number, nFrames: number) => Float32Array;
-  tempogram: (
-    onsetEnvelope: Float32Array,
-    sampleRate: number,
-    hopLength: number,
-    winLength: number,
-    mode: TempogramMode,
-  ) => WasmTempogramResult;
-  cyclicTempogram: (
-    onsetEnvelope: Float32Array,
-    sampleRate: number,
-    hopLength: number,
-    winLength: number,
-    bpmMin: number,
-    nBins: number,
-  ) => WasmCyclicTempogramResult;
-  plp: (
-    onsetEnvelope: Float32Array,
-    sampleRate: number,
-    hopLength: number,
-    tempoMin: number,
-    tempoMax: number,
-    winLength: number,
-  ) => Float32Array;
-  nnlsChroma: (samples: Float32Array, sampleRate: number) => WasmNnlsChromaResult;
-  cqt: (
-    samples: Float32Array,
-    sampleRate: number,
-    hopLength: number,
-    fmin: number,
-    nBins: number,
-    binsPerOctave: number,
-  ) => WasmCqtResult;
-  vqt: (
-    samples: Float32Array,
-    sampleRate: number,
-    hopLength: number,
-    fmin: number,
-    nBins: number,
-    binsPerOctave: number,
-    gamma: number,
-  ) => WasmCqtResult;
-  analyzeSections: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    minSectionSec: number,
-  ) => WasmSectionResult[];
-  analyzeMelody: (
-    samples: Float32Array,
-    sampleRate: number,
-    fmin: number,
-    fmax: number,
-    frameLength: number,
-    hopLength: number,
-    threshold: number,
-  ) => WasmMelodyResult;
-  onsetEnvelope: (
-    samples: Float32Array,
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    nMels: number,
-  ) => Float32Array;
-  fourierTempogram: (
-    onsetEnvelope: Float32Array,
-    sampleRate: number,
-    hopLength: number,
-    winLength: number,
-  ) => WasmFourierTempogramResult;
-  tempogramRatio: (
-    tempogramData: Float32Array,
-    winLength: number,
-    sampleRate: number,
-    hopLength: number,
-  ) => Float32Array;
-  lufs: (samples: Float32Array, sampleRate: number) => WasmLufsResult;
-  momentaryLufs: (samples: Float32Array, sampleRate: number) => Float32Array;
-  shortTermLufs: (samples: Float32Array, sampleRate: number) => Float32Array;
-  resample: (samples: Float32Array, srcSr: number, targetSr: number) => Float32Array;
-
-  StreamAnalyzer: new (
-    sampleRate: number,
-    nFft: number,
-    hopLength: number,
-    nMels: number,
-    fmin: number,
-    fmax: number,
-    tuningRefHz: number,
-    computeMagnitude: boolean,
-    computeMel: boolean,
-    computeChroma: boolean,
-    computeOnset: boolean,
-    computeSpectral: boolean,
-    emitEveryNFrames: number,
-    magnitudeDownsample: number,
-    keyUpdateIntervalSec: number,
-    bpmUpdateIntervalSec: number,
-    window: number,
-    outputFormat: number,
-  ) => WasmStreamAnalyzer;
-  RealtimeEngine: new (
-    sampleRate: number,
-    maxBlockSize: number,
-    commandCapacity: number,
-    telemetryCapacity: number,
-  ) => WasmRealtimeEngine;
-
-  createStreamingMasteringChain: (config: Record<string, unknown>) => WasmStreamingMasteringChain;
-  createEqualizer: (config: Record<string, unknown>) => WasmStreamingEqualizer;
-  createStreamingRetune: (config: Record<string, unknown>) => WasmStreamingRetune;
-  createMixerFromSceneJson: (json: string, sampleRate: number, blockSize: number) => WasmMixer;
-  mixerPresetJson: (presetName: string) => string;
-}