@kidlib/web-audio 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1283 @@
+declare type AudioContextConfig = {
+    sampleRate?: number;
+    latencyHint?: AudioContextLatencyCategory;
+};
+
+declare const AudioRecorderState: {
+    readonly IDLE: "IDLE";
+    readonly ARMED: "ARMED";
+    readonly RECORDING: "RECORDING";
+    readonly STOPPED: "STOPPED";
+};
+
+declare type AudioRecorderState = (typeof AudioRecorderState)[keyof typeof AudioRecorderState];
+
+declare type BaseNodeType = 'instrument' | 'voice' | 'fx' | 'param' | 'container' | 'recorder' | 'audiograph';
+
+declare type BusNodeName = 'input' | 'output' | 'dryMix' | 'wetMix' | 'hpf' | 'lpf' | 'distortion' | 'feedback' | 'reverb' | 'compressor' | 'limiter' | 'delay';
+
+declare type BusNodeTypeMap = {
+    input: ILibAudioNode<GainNode>;
+    lpf: ILibAudioNode<BiquadFilterNode>;
+    hpf: ILibAudioNode<BiquadFilterNode>;
+    dryMix: ILibAudioNode<GainNode>;
+    wetMix: ILibAudioNode<GainNode>;
+    output: ILibAudioNode<GainNode>;
+    compressor: ILibAudioNode<DynamicsCompressorNode>;
+    limiter: ILibAudioNode<DynamicsCompressorNode>;
+    feedback: HarmonicFeedback;
+    distortion: ILibAudioNode<DistortionWorklet>;
+    reverb: DattorroReverb;
+    delay?: ILibAudioNode<DelayWorklet>;
+};
+
+declare type BusSendName = `${BusNodeName}_send`;
+
+/** False in Safari — AudioContext.setSinkId is Chromium/Firefox only */
+export declare function canSetOutputDevice(): boolean;
+
+declare type ContainerType = 'pool' | 'chain' | 'audiolib';
+
+/**
+ * Creates and initializes a new audio recorder
+ *
+ * @param context - Optional AudioContext to use. If not provided, the global audio context will be used.
+ * @returns A promise that resolves to the initialized Recorder instance // ! unnecessary async
+ */
+export declare function createAudioRecorder(context?: AudioContext): Promise<Recorder>;
+
+/**
+ * Creates a new SamplePlayer instance
+ *
+ * @param buffer - Optional audio buffer to use (will use default if not provided)
+ * @param polyphony - Number of voices for polyphony (default: 16)
+ * @param context - Optional AudioContext (will use global context if not provided)
+ * @returns A new SamplePlayer instance
+ */
+export declare function createSamplePlayer(buffer?: AudioBuffer | ArrayBuffer, polyphony?: number, context?: AudioContext): Promise<SamplePlayer>;
+
+/** Custom Audiolib waveform */
+declare const CUSTOM_WAVEFORMS: readonly ["pulse", "bandlimited-sawtooth", "supersaw", "warm-pad", "metallic", "formant", "white-noise", "pink-noise", "brown-noise", "colored-noise", "random-harmonic", "custom-function"];
+
+export declare class CustomEnvelope implements LibNode {
+    #private;
+    readonly nodeId: NodeID_2;
+    readonly nodeType: EnvelopeType;
+    envelopeType: EnvelopeType;
+    constructor(context: AudioContext, envelopeType: EnvelopeType, sharedData?: EnvelopeData, initialPoints?: EnvelopePoint[], envPointValueRange?: [number, number], durationSeconds?: number, initEnable?: boolean);
+    addPoint: (time: number, value: number, curve?: "linear" | "exponential") => void;
+    deletePoint: (index: number) => void;
+    updatePoint: (index: number, time?: number, value?: number) => void;
+    setSampleDuration(seconds: number): this;
+    setValueRange: (range: [number, number]) => [number, number];
+    enable: () => boolean;
+    disable: () => boolean;
+    get initialized(): boolean;
+    get data(): EnvelopeData;
+    get param(): string;
+    get isEnabled(): boolean;
+    get points(): EnvelopePoint[];
+    get baseDuration(): number;
+    get effectiveDuration(): number;
+    get timeScale(): number;
+    /**
+     * The range of values applied to the audio param
+     **/
+    get envPointValueRange(): [number, number];
+    get loopEnabled(): boolean;
+    get syncedToPlaybackRate(): boolean;
+    get numPoints(): number;
+    getEffectivePointTime(index: number): number;
+    triggerEnvelope(audioParam: AudioParam, startTime: number, options?: {
+        baseValue: number;
+        playbackRate: number;
+        voiceId?: string;
+        midiNote?: number;
+    }): void;
+    releaseEnvelope(audioParam: AudioParam, startTime: number, options?: {
+        baseValue?: number;
+        playbackRate?: number;
+        voiceId?: string;
+        midiNote?: number;
+        minValue?: number;
+        maxValue?: number;
+    }, debugLog?: boolean): void;
+    setTimeScale: (timeScale: number) => void;
+    setLoopEnabled: (enabled: boolean, mode?: "normal" | "ping-pong" | "reverse") => void;
+    syncToPlaybackRate: (sync: boolean) => void;
+    setSustainPoint: (index: number | null) => void;
+    setReleasePoint: (index: number) => void;
+    get sustainPointIndex(): number | null;
+    get releasePointIndex(): number;
+    get releasePoint(): EnvelopePoint | null;
+    get effectiveReleaseStartTime(): number;
+    get baseReleaseDuration(): number;
+    get effectiveReleaseDuration(): number;
+    get sustainEnabled(): boolean;
+    get sustainPoint(): EnvelopePoint | null;
+    get currentPlaybackRate(): number;
+    setCurrentPlaybackRate(playbackRate: number): void;
+    onMessage(type: string, handler: MessageHandler<Message>): () => void;
+    sendUpstreamMessage(type: string, data: any): this;
+    hasVariation(): boolean;
+    static getDefaults(envType: EnvelopeType, durationSeconds?: number): {
+        points: {
+            time: number;
+            value: number;
+            curve: "exponential";
+        }[];
+        envPointValueRange: [number, number];
+        initEnable: boolean;
+        sustainPointIndex: null;
+        releasePointIndex: number;
+    } | {
+        points: {
+            time: number;
+            value: number;
+            curve: "linear";
+        }[];
+        envPointValueRange: [number, number];
+        initEnable: boolean;
+        sustainPointIndex: null;
+        releasePointIndex: number;
+    };
+    dispose(): void;
+}
+
+declare type CustomFxType = 'feedback-delay' | 'harmonic-feedback' | 'distortion' | 'dattorro-reverb';
+
+declare type CustomLibWaveform = (typeof CUSTOM_WAVEFORMS)[number];
+
+declare class DattorroReverb implements ILibAudioNode {
+    #private;
+    readonly nodeId: NodeID_2;
+    readonly nodeType: NodeType;
+    static readonly PRESETS: {
+        readonly room: {
+            readonly preDelay: 1525;
+            readonly bandwidth: 0.5683;
+            readonly inputDiffusion1: 0.4666;
+            readonly inputDiffusion2: 0.5853;
+            readonly decay: 0.3226;
+            readonly decayDiffusion1: 0.6954;
+            readonly decayDiffusion2: 0.6022;
+            readonly damping: 0.6446;
+            readonly excursionRate: 0;
+            readonly excursionDepth: 0;
+        };
+        readonly church: {
+            readonly preDelay: 0;
+            readonly bandwidth: 0.928;
+            readonly inputDiffusion1: 0.7331;
+            readonly inputDiffusion2: 0.4534;
+            readonly decay: 0.7;
+            readonly decayDiffusion1: 0.7839;
+            readonly decayDiffusion2: 0.1992;
+            readonly damping: 0.5975;
+            readonly excursionRate: 0;
+            readonly excursionDepth: 0;
+        };
+        readonly freeze: {
+            readonly preDelay: 0;
+            readonly bandwidth: 0.999;
+            readonly inputDiffusion1: 0.75;
+            readonly inputDiffusion2: 0.625;
+            readonly decay: 1;
+            readonly decayDiffusion1: 0.5;
+            readonly decayDiffusion2: 0.711;
+            readonly damping: 0.005;
+            readonly excursionRate: 0.3;
+            readonly excursionDepth: 1.4;
+        };
+        readonly ether: {
+            readonly preDelay: 0;
+            readonly bandwidth: 0.999;
+            readonly inputDiffusion1: 0.23;
+            readonly inputDiffusion2: 0.667;
+            readonly decay: 0.45;
+            readonly decayDiffusion1: 0.7;
+            readonly decayDiffusion2: 0.5;
+            readonly damping: 0.3;
+            readonly excursionRate: 0.85;
+            readonly excursionDepth: 1.2;
+        };
+        readonly default: {
+            readonly preDelay: 0;
+            readonly bandwidth: 0.85;
+            readonly inputDiffusion1: 0.4;
+            readonly inputDiffusion2: 0.45;
+            readonly decay: 0.1;
+            readonly decayDiffusion1: 0.5;
+            readonly decayDiffusion2: 0.45;
+            readonly damping: 0.25;
+            readonly excursionRate: 0.3;
+            readonly excursionDepth: 0.3;
+        };
+    };
+    constructor(context?: AudioContext);
+    connect(destination: ILibAudioNode | AudioNode): void;
+    disconnect(destination?: ILibAudioNode | AudioNode): void;
+    addIncoming(source: ILibAudioNode): void;
+    removeIncoming(source: ILibAudioNode): void;
+    setParam(name: string, value: number, time?: number): void;
+    getAudioParam(name: string): AudioParam | null;
+    setAmountMacro(amount: number): void;
+    setPreset(preset?: 'room' | 'church' | 'freeze' | 'ether' | 'default', rampTime?: number): void;
+    /**
+     DIFFUSION PARAMETER (0.0 - 1.0, default: 0.7)
+     Controls reverb density and scatter. Higher = more complex tail.
+
+     0.0 - No diffusion, echoes/delays only        | Special effects, rhythmic delays
+     0.3 - Light scatter, clear open sound         | Vocals, acoustic instruments
+     0.5 - Moderate density, balanced              | General purpose, drums
+     0.7 - Rich diffusion, full reverb tail        | Orchestral, ambient music
+     0.9 - Very dense, thick complex tail          | Dense mixes, sound design
+     1.0 - Maximum density, can sound harsh        | Experimental/aggressive sounds
+     **/
+    setDiffusionMacro(value: number): void;
+    getDiffusionMacroValue(): number;
+    getCurrentSettings(): Record<string, number>;
+    get audioNode(): AudioWorkletNode;
+    get context(): AudioContext;
+    get input(): AudioNode;
+    get output(): AudioNode;
+    get now(): number;
+    get initialized(): boolean;
+    get currentPreset(): "default" | "room" | "church" | "freeze" | "ether";
+    get connections(): {
+        outgoing: string[];
+        incoming: string[];
+    };
+    get numberOfInputs(): number;
+    get numberOfOutputs(): number;
+    get workletInfo(): {
+        numberOfInputs: number;
+        numberOfOutputs: number;
+        channelCount: number;
+        channelCountMode: ChannelCountMode;
+    };
+    dispose(): void;
+}
+
+export declare const DEFAULT_KEYMAP_KEY: KeymapKey;
+
+/**
+ * Default keyboard-to-MIDI note mapping for audio input.
+ * Provides a piano-like layout across the QWERTY keyboard.
+ * Used by KeyboardInputManager to translate keyboard events to MIDI notes.
+ */
+export declare const defaultKeymap: KeyMap;
+
+declare interface DefaultWorkletConfig extends WorkletConfig {
+    params: WorkletParameters;
+    message: WorkletMessage;
+}
+
+declare type DelayCharacter = 'clean' | 'bitCrushed' | 'filtered';
+
+declare type DelayConfig = {
+    params: DelayParams;
+    message: DelayMsg;
+};
+
+declare type DelayMsg = SetDelayCharacterMsg | TriggerDelayMsg;
+
+declare type DelayParams = {
+    delayTime: number;
+    feedbackAmount: number;
+};
+
+declare type DelayWorklet = WorkletNode<DelayConfig>;
+
+declare type Destination = ILibAudioNode | AudioNode | AudioParam;
+
+declare type DistortionConfig = {
+    params: DistortionParams;
+    message: DistortionMsg;
+};
+
+declare type DistortionMsg = {
+    type: 'setLimitingMode';
+    mode: 'soft-clipping' | 'hard-clipping';
+};
+
+declare type DistortionParams = {
+    clippingThreshold: number;
+    clippingAmount: number;
+    distortionDrive: number;
+};
+
+declare type DistortionWorklet = WorkletNode<DistortionConfig>;
+
+export declare function ensureAudioCtx(config?: AudioContextConfig): Promise<AudioContext>;
+
+export declare class EnvelopeData {
+    #private;
+    points: EnvelopePoint[];
+    constructor(points: EnvelopePoint[] | undefined, valueRange: [number, number] | undefined, durationSeconds: number, sustainIdx?: number, releaseIdx?: number);
+    addPoint(time: number, value: number, curve?: 'linear' | 'exponential'): void;
+    updatePoint(index: number, time?: number, value?: number): void;
+    updateStartPoint: (time?: number, value?: number) => void;
+    updateEndPoint: (time?: number, value?: number) => void;
+    deletePoint(index: number): void;
+    interpolateValueAtTime(timeSeconds: number): number;
+    setSustainPoint(index: number | null): void;
+    setReleasePoint(index: number): void;
+    get startPointIndex(): number;
+    get sustainPointIndex(): number | null;
+    get releasePointIndex(): number;
+    get endPointIndex(): number;
+    get pointValueRange(): [number, number];
+    setValueRange: (range: [number, number]) => [number, number];
+    get startTime(): number;
+    get endTime(): number;
+    get durationSeconds(): number;
+    setDurationSeconds(seconds: number): void;
+    get hasSharpTransitions(): boolean;
+}
+
+export declare type EnvelopePoint = {
+    time: number;
+    value: number;
+    curve?: 'linear' | 'exponential';
+};
+
+export declare type EnvelopeType = 'amp-env' | 'pitch-env' | 'filter-env' | 'loop-env' | 'default-env';
+
+declare type FbDelayConfig = {
+    params: FbDelayParams;
+    message: FbDelayMsg;
+};
+
+declare type FbDelayMsg = {
+    type: 'setAutoGain';
+    enabled: boolean;
+    amount: number;
+} | {
+    type: 'triggerDecay';
+    baseFeedbackAmount: number;
+} | {
+    type: 'stopDecay';
+};
+
+declare type FbDelayParams = {
+    delayTime: number;
+    feedbackAmount: number;
+    decayAmount: number;
+};
+
+declare type FbDelayWorklet = WorkletNode<FbDelayConfig>;
+
+/**
+ * Generate a keymap from a base note and scale intervals.
+ * Each QWERTY row is mapped one octave above the previous (bottom row lowest).
+ */
+export declare function generateKeymap(config: {
+    baseNote: number;
+    scale: number[];
+}): KeyMap;
+
+export declare function getAudioContext(config?: AudioContextConfig): AudioContext;
+
+/** Device labels are only populated once mic permission has been granted */
+export declare function getAudioInputDevices(): Promise<MediaDeviceInfo[]>;
+
+/** Device labels are only populated once mic permission has been granted */
+export declare function getAudioOutputDevices(): Promise<MediaDeviceInfo[]>;
+
+export declare function getCurrentOutputDeviceId(): string;
+
+declare class HarmonicFeedback implements ILibAudioNode {
+    #private;
+    readonly nodeId: NodeID;
+    readonly nodeType: NodeType;
+    constructor(context?: AudioContext);
+    trigger(midiNote: number, options?: {
+        glideTime?: number;
+        velocity?: number;
+        secondsFromNow?: number;
+        cents?: number;
+        triggerDecay?: boolean;
+    }): this;
+    setAmountMacro(amount: number): this;
+    get currentAmount(): number;
+    setPitch(midiNote: number, cents?: number, timestamp?: number, glideTime?: number): number;
+    setDelay(seconds: number, timestamp?: number, glideTime?: number): this;
+    setDelayMultiplier(value: number, timestamp?: number, glideTime?: number): this | undefined;
+    setFeedbackAmount(amount: number, timestamp?: number): this;
+    setAutoGain(enabled: boolean, amount: number): this;
+    setDecay(amount: number, timestamp?: number): this;
+    setLowpassCutoff(freqHz: number): void;
+    connect(destination: ILibAudioNode | AudioNode): void;
+    disconnect(destination?: ILibAudioNode | AudioNode): void;
+    addIncoming(source: ILibAudioNode): void;
+    removeIncoming(source: ILibAudioNode): void;
+    setParam(name: string, value: number, time?: number): void;
+    getAudioParam(name: string): AudioParam | null;
+    get audioNode(): FbDelayWorklet;
+    get context(): AudioContext;
+    get now(): number;
+    get input(): GainNode;
+    get output(): GainNode;
+    get connections(): {
+        outgoing: string[];
+        incoming: string[];
+    };
+    get initialized(): boolean;
+    get decayActive(): boolean;
+    get numberOfInputs(): number;
+    get numberOfOutputs(): number;
+    get workletInfo(): {
+        numberOfInputs: number;
+        numberOfOutputs: number;
+        channelCount: number;
+        channelCountMode: ChannelCountMode;
+    };
+    dispose(): void;
+}
+
+/** Adapter interface for web native and Audiolib's custom audio nodes */
+declare interface ILibAudioNode<T extends AudioNode | AudioWorkletNode = AudioNode> extends LibNode {
+    connect(destination: ILibAudioNode | AudioNode): void;
+    disconnect(destination?: ILibAudioNode | AudioNode): void;
+    setParam(name: string, value: number, time?: number): void;
+    getAudioParam(name: string): AudioParam | null;
+    onMessage?(type: string, handler: MessageHandler<Message>): () => void;
+    readonly now: number;
+    readonly audioNode: T;
+    readonly context: AudioContext | BaseAudioContext;
+    readonly connections: {
+        outgoing: NodeID_2[];
+        incoming: NodeID_2[];
+    };
+    readonly input: AudioNode;
+    readonly output: AudioNode;
+}
+
+/** Extends ILibAudioNode with core Instrument features */
+declare interface ILibInstrumentNode extends ILibAudioNode {
+    play(midiNote: MidiValue, velocity?: number): MidiValue | null;
+    release(note: MidiValue): this;
+    releaseAll(releaseTime?: number): this;
+    outBus?: InstrumentBus;
+}
+
+declare class InstrumentBus implements ILibAudioNode {
+    #private;
+    readonly nodeId: NodeID_2;
+    readonly nodeType = "InstrumentBus";
+    constructor(context?: AudioContext);
+    createGainNode(context: AudioContext, options?: {
+        initialGain?: number;
+    }): ILibAudioNode<GainNode>;
+    init(): Promise<void>;
+    getNode<K extends BusNodeName>(name: K): BusNodeTypeMap[K];
+    getNode(name: BusSendName): ILibAudioNode<GainNode> | undefined;
+    getSendNode: (name: BusNodeName) => ILibAudioNode<GainNode> | undefined;
+    removeNode(name: string): this;
+    noteOn(midiNote: number, velocity?: number, secondsFromNow?: number, glideTime?: number): this;
+    setSendAmount(effect: BusNodeName, amount: number): this;
+    setHpfCutoff(hz: number): this;
+    setLpfCutoff(hz: number): this;
+    setCompressorParams(params: {
+        threshold?: number;
+        knee?: number;
+        ratio?: number;
+        attack?: number;
+        release?: number;
+    }): this;
+    setDryWetMix(mix: {
+        dry: number;
+        wet: number;
+    }): this;
+    setDelayTime(seconds: number): this;
+    setDelayFeedback(amount: number): this;
+    /**
+     * Set the character modes for the delay processor, in the order in which to process (e.g. ['filtered', 'bitCrushed'])
+     */
+    setDelayCharacter(modes: Array<'clean' | 'bitCrushed' | 'filtered'>): this;
+    setReverbSize(amount: number): this;
+    setReverbDecay(decay: number): this;
+    setDistortionMacro(amount: number): void;
+    setDrive(amount: number): this;
+    setClippingMacro(amount: number): this;
+    setClippingMode(mode: 'soft-clipping' | 'hard-clipping'): void;
+    setFeedbackAmount(amount: number): this;
+    setFeedbackPitchScale(value: number): this;
+    setFeedbackDecay(amount: number): this;
+    setFeedbackLowpassCutoff(amount: number): this;
+    connect(destination: ILibAudioNode | AudioNode): void;
+    disconnect(destination?: ILibAudioNode | AudioNode): void;
+    addIncoming(sourceNodeId: NodeID_2): void;
+    removeIncoming(sourceNodeId: NodeID_2): void;
+    setParam(name: string, value: number): void;
+    getAudioParam(name: string): AudioParam | null;
+    getInput(): ILibAudioNode<GainNode>;
+    getOutput(): ILibAudioNode<GainNode>;
+    getLpf(): ILibAudioNode<BiquadFilterNode>;
+    getHpf(): ILibAudioNode<BiquadFilterNode>;
+    getDryMix(): ILibAudioNode<GainNode>;
+    getWetMix(): ILibAudioNode<GainNode>;
+    getCompressor(): ILibAudioNode<DynamicsCompressorNode>;
+    getLimiter(): ILibAudioNode<DynamicsCompressorNode>;
+    getDistortion(): ILibAudioNode<DistortionWorklet>;
+    getReverb(): DattorroReverb;
+    getFeedback(): HarmonicFeedback;
+    dispose(): void;
+    get audioNode(): GainNode;
+    get context(): AudioContext;
+    get connections(): {
+        outgoing: string[];
+        incoming: string[];
+    };
+    get input(): GainNode;
+    get output(): GainNode;
+    get now(): number;
+    set outputLevel(level: number);
+    get outputLevel(): number;
+    get initialized(): boolean;
+    get dryWetMix(): {
+        dry: number;
+        wet: number;
+    };
+    getSendAmount(effect: BusNodeName): number;
+    getRoutingMap(): Record<string, string[]>;
+    debugRouting(): void;
+    debugSends(): void;
+    listNodes(): string[];
+    startLevelMonitoring(intervalMs?: number, fftSize?: number, logOutput?: boolean): void;
+    stopLevelMonitoring(): void;
+    logLevels(): void;
+    onMessage(type: string, handler: MessageHandler<Message>): () => void;
+}
+
+declare type InstrumentType = 'sample-player' | 'synth';
+
+export declare type KeyMap = Record<string, number>;
+
+export declare type KeymapKey = 'piano' | 'major' | 'minor' | 'pentatonic' | 'chromatic';
+
+export declare const keymaps: Record<KeymapKey, KeyMap>;
+
+declare class LFO {
+    #private;
+    constructor(context: AudioContext);
+    setFrequency(hz: number, timestamp?: number): void;
+    setDepth(amount: number, timestamp?: number): void;
+    setWaveform(waveform: OscillatorType | PeriodicWave | CustomLibWaveform, customWaveOptions?: WaveformOptions): void;
+    setPeriodicWave(wave: PeriodicWave): void;
+    connect(audioParam: AudioParam): void;
+    disconnect(audioParam?: AudioParam): void;
+    setMusicalNote(midiNote: number, options?: {
+        divisor?: number;
+        glideTime?: number;
+        timestamp?: number;
+        glideFromMidiNote?: number;
+    }): this | undefined;
+    storeCurrentValues: () => void;
+    getStoredValues: () => {
+        rate: number;
+        depth?: number;
+    } | null;
+    getPitchWobbleWaveform(): PeriodicWave;
+    get now(): number;
+    dispose(): void;
+}
+
+export declare class LibAudioNode<T extends AudioNode | AudioWorkletNode = AudioNode> implements ILibAudioNode<T> {
+    #private;
+    readonly nodeId: NodeID_2;
+    readonly nodeType: NodeType;
+    constructor(node: T, context: AudioContext, nodeType: NodeType, options?: LibAudioNodeOptions);
+    onMessage(type: string, handler: MessageHandler<Message>): () => void;
+    sendUpstreamMessage(type: string, data: any): this;
+    connect(destination: ILibAudioNode | AudioNode): void;
+    disconnect(destination?: ILibAudioNode | AudioNode): void;
+    addIncoming(sourceNodeId: NodeID_2): void;
+    removeIncoming(sourceNodeId: NodeID_2): void;
+    get connections(): {
+        outgoing: string[];
+        incoming: string[];
+    };
+    setParam(name: string, value: number, timestamp?: number): void;
+    getAudioParam(name: string): AudioParam | null;
+    get audioNode(): T;
+    get input(): AudioNode | AudioWorkletNode;
+    get output(): AudioNode | AudioWorkletNode;
+    get context(): BaseAudioContext;
+    get now(): number;
+    get initialized(): boolean;
+    dispose(): void;
+}
+
+declare interface LibAudioNodeOptions {
+    createIOGains?: boolean;
+}
+
+export declare interface LibNode {
+    readonly nodeId: NodeID_2;
+    readonly nodeType: NodeType;
+    readonly initialized: boolean;
+    dispose(): void;
+}
+
+declare class MacroParam {
+    #private;
+    readonly nodeType: string;
+    readonly nodeId: NodeID;
+    constructor(context: BaseAudioContext, initialValue: number);
+    init(): Promise<void>;
+    addTarget(targetParam: AudioParam, paramType: string, scaleFactor?: number): this;
+    ramp(targetValue: number, duration: number, constant: number, options?: {
+        method?: 'exponential' | 'linear';
+        debounceMs?: number;
+        onComplete?: () => void;
+        onCompleteDelayMs?: number;
+    }): this;
+    debugProcessVal(value: number, constant: number, targetPeriod: number): void;
+    setAllowedParamValues(values: number[], normalize: NormalizeOptions | false): number[];
+    setAllowedPeriods(periods: number[], normalize: NormalizeOptions | false, snapToZeroCrossings?: number[] | false): number[];
+    setScale(options: {
+        rootNote: keyof typeof ROOT_NOTES;
+        scale: keyof typeof SCALE_PATTERNS | number[];
+        tuningOffset: number;
+        highestOctave: number;
+        lowestOctave: number;
+        snapToZeroCrossings: number[] | false;
+        normalize: NormalizeOptions | false;
+    }): number[];
+    setValue(value: number, timestamp?: number): this;
+    getValue: () => number;
+    get targetValue(): number;
+    get targets(): {
+        param: AudioParam;
+        scaler?: GainNode;
+    }[];
+    get snapper(): ValueSnapper;
+    get rootNote(): "C" | "C#" | "Db" | "D" | "D#" | "Eb" | "E" | "F" | "F#" | "Gb" | "G" | "G#" | "Ab" | "A" | "A#" | "Bb" | "B";
+    setRootNote(rootNote: keyof typeof ROOT_NOTES): void;
+    get scalePattern(): number[];
+    get isReady(): boolean;
+    get now(): number;
+    get audioParam(): AudioParam;
+    get type(): string;
+    get longestPeriod(): number;
+    onChange(callback: MessageHandler<Message>): () => void;
+    onMessage(type: string, handler: MessageHandler<Message>): () => void;
+    protected sendMessage(type: string, data: any): void;
+    dispose(): void;
+    connect(target: AudioParam, nodeType: NodeType, scaleFactor?: number): this;
+    disconnect(target?: AudioParam | TODO): void;
+}
+
+declare interface Message {
+    readonly type: string;
+    readonly senderId: NodeID_2;
+    [key: string]: any;
+}
+
+declare type MessageHandler<T> = (data: T) => void;
+
+declare type NativeAudioNode = 'AudioWorkletNode' | 'GainNode' | 'BiquadFilterNode' | 'AudioBufferSourceNode' | 'DynamicsCompressorNode';
+
+declare type NodeID_2 = string;
+
+declare type NodeType = NativeAudioNode | BaseNodeType | InstrumentType | VoiceType | ContainerType | string | CustomFxType;
+
+declare type NormalizeOptions = {
+    from: [number, number];
+    to: [number, number];
+};
+
+/**
+ * Represents a musical note with all its properties
+ */
+declare type Note = {
+    name: string;
+    octave: number;
+    midiNote: number;
+    frequency: number;
+    period: number;
+};
+
+export declare class Oscilloscope {
+    private node;
+    private canvas;
+    private canvasCtx;
+    private get width();
+    private get height();
+    constructor(ctx: AudioContext, input: AudioNode, canvas: HTMLCanvasElement);
+    run(): void;
+    render(data: Uint8Array): void;
+    getWaveform(data: Uint8Array): Uint8Array;
+}
+
+declare type PreProcessOptions = {
+    skipPreProcessing?: boolean;
+    normalize?: {
+        enabled: boolean;
+        maxAmplitudePeak?: number;
+    };
+    compress?: {
+        enabled: boolean;
+        threshold?: number;
+        ratio?: number;
+        makeupGain?: number;
+    };
+    trimSilence?: {
+        enabled: boolean;
+        threshold?: number;
+    };
+    fadeInOutMs?: number;
+    tune?: {
+        detectPitch?: boolean;
+        autotune: boolean;
+        targetMidiNote?: number;
+    };
+    hpf?: {
+        auto?: boolean;
+    } | {
+        cutoff?: number;
+    };
+    getZeroCrossings?: boolean;
+};
+
+export declare class Recorder implements LibNode {
+    #private;
+    readonly nodeId: NodeID_2;
+    readonly nodeType = "recorder";
+    constructor(context: AudioContext);
+    init(): Promise<Recorder>;
+    start(options?: RecorderStartOptions): Promise<this>;
+    forceStart(): boolean;
+    /**
+     * Aborts an armed or in-progress recording without producing a buffer.
+     * Releases the input stream, so a new `start()` is required to record again.
+     *
+     * @returns true if a recording was cancelled, false if there was nothing to cancel.
+     */
+    cancel(): boolean;
+    stop(): Promise<AudioBuffer>;
+    onMessage(type: string, handler: MessageHandler<Message>): () => void;
+    protected sendMessage(type: string, data: any): void;
+    connect(destination: LibNode & SampleLoader): this;
+    disconnect(): void;
+    dispose(): void;
+    get isArmed(): boolean;
+    get isRecording(): boolean;
+    get state(): AudioRecorderState;
+    get initialized(): boolean;
+    get now(): number;
+    get destination(): (LibNode & SampleLoader) | null;
+}
+
+export declare type RecorderInput = {
+    type: 'microphone';
+    deviceId?: string;
+} | {
+    type: 'display';
+} | {
+    type: 'audio-node';
+    node: AudioNode;
+};
+
+declare type RecorderOptions = {
+    mediaRecorderOptions: MediaRecorderOptions;
+    useThreshold: boolean;
+    startThreshold: number;
+    autoStop: boolean;
+    stopThreshold: number;
+    silenceTimeoutMs: number;
+    preprocess: boolean;
+    preprocessOptions: object;
+};
+
+export declare type RecorderStartOptions = Partial<RecorderOptions> & {
+    input?: RecorderInput;
+};
+
+declare const ROOT_NOTES: {
+    readonly C: 0;
+    readonly 'C#': 1;
+    readonly Db: 1;
+    readonly D: 2;
+    readonly 'D#': 3;
+    readonly Eb: 3;
+    readonly E: 4;
+    readonly F: 5;
+    readonly 'F#': 6;
+    readonly Gb: 6;
+    readonly G: 7;
+    readonly 'G#': 8;
+    readonly Ab: 8;
+    readonly A: 9;
+    readonly 'A#': 10;
+    readonly Bb: 10;
+    readonly B: 11;
+};
+
+export declare interface SampleLoader {
+    loadSample(...args: TODO[]): Promise<TODO>;
+}
+
+export declare class SamplePlayer implements ILibInstrumentNode {
+    #private;
+    readonly nodeId: NodeID_2;
+    readonly nodeType: "sample-player";
+    readonly context: AudioContext;
+    randomizeVelocity: boolean;
+    voicePool: SampleVoicePool;
+    outBus: InstrumentBus;
+    constructor(context: AudioContext, polyphony?: number, audioBuffer?: AudioBuffer);
+    init(): Promise<void>;
+    onMessage(type: string, handler: MessageHandler<Message>): () => void;
+    sendUpstreamMessage(type: string, data: any): this;
+    connect(destination: ILibInstrumentNode | AudioNode): void;
+    disconnect(destination?: ILibInstrumentNode | AudioNode): void;
+    addIncoming(source: ILibInstrumentNode): void;
+    removeIncoming(source: ILibInstrumentNode): void;
+    get connections(): {
+        outgoing: string[];
+        incoming: string[];
+    };
+    get audioNode(): GainNode;
+    get input(): GainNode;
+    get output(): GainNode;
+    get now(): number;
+    get initialized(): boolean;
+    getMacrosAudioParam(paramName: 'loopStart' | 'loopEnd'): AudioParam;
+    getMacro(paramName: 'loopStart' | 'loopEnd'): MacroParam;
+    setModulationAmount: (modType: "AM" | "FM", amount: number) => void;
+    setModulationWaveform(modType?: 'AM' | 'FM', waveform?: CustomLibWaveform | OscillatorType | PeriodicWave, customWaveOptions?: WaveformOptions): void;
+    syncLFOsToNoteFreq(lfoId: 'gain-lfo' | 'pitch-lfo', enabled: boolean): void;
+    freezeActiveVoices(freeze: boolean): this;
+    loadSample(buffer: AudioBuffer | ArrayBuffer, modSampleRate?: number, preprocessOptions?: Partial<PreProcessOptions>): Promise<AudioBuffer | null>;
+    cropSample(startSeconds?: number, endSeconds?: number, fadeMs?: number): Promise<AudioBuffer | null>;
+    detectPitch(buffer: AudioBuffer): Promise<{
+        frequency: number;
+        confidence: number;
+        midiFloat: number;
+        targetNoteInfo: Note;
+    }>;
+    detectedPitchToTransposition(detectedMidiFloat: number, targetMidiNote: number): number;
+    play(midiNote: MidiValue, velocity?: MidiValue, glideTime?: number): MidiValue | null;
+    release(midiNote: MidiValue): this;
+    releaseAll(releaseTime?: number): this;
+    panic: (releaseTime?: number) => this;
+    get transposedBySemitones(): number;
+    set transposeSemitones(semitones: number);
+    setScale(options: {
+        rootNote: keyof typeof ROOT_NOTES;
+        scale: number[];
+        tuningOffset: number;
+        highestOctave: number;
+        lowestOctave: number;
+        normalize: NormalizeOptions | false;
+    }): this;
+    setRootNote(note: keyof typeof ROOT_NOTES): this;
+    /** PARAM SETTERS  */
+    setVolume(volume: number): this;
+    setSampleStartPoint(seconds: number): this;
+    setSampleEndPoint(seconds: number): this;
+    setLoopRampDuration(seconds: number): this;
+    setGlideTime(seconds: number): this;
+    setLoopEnabled(enabled: boolean): this;
+    setLoopLocked(locked: boolean): this;
+    setHoldEnabled(enabled: boolean): this;
+    setHoldLocked(locked: boolean): this;
+    setSustainPedal(pressed: boolean): this;
+    sustainPedalOn: () => this;
+    sustainPedalOff: () => this;
+    setPlaybackDirection(direction: 'forward' | 'reverse'): this;
+    setLoopDurationDriftAmount(amount: number): this;
+    setPanDriftEnabled: (enabled: boolean) => this;
+    setTimestretchEnabled: (enabled: boolean) => this;
+    isNormalized: (value: number, range?: number[]) => boolean;
+    readonly MIN_LOOP_DURATION_SECONDS: number;
+    setLoopStart: (seconds: number, rampTime?: number) => this;
+    setLoopEnd: (seconds: number, rampTime?: number) => this;
+    setLoopDuration: (seconds: number, rampTime?: number) => this;
+    debugcounter: number;
+    setTempo(bpm: number): this | undefined;
+    syncLoopToTempo(enabled: boolean): this;
+    setKeytrackLoopAmount(amount: number): this;
+    getKeytrackLoopAmount: () => number;
+    get tempo(): number;
+    setLoopPoint(loopPoint: 'start' | 'end', loopStartSeconds: number, loopEndSeconds: number, rampDuration?: number): this;
+    scrollLoopPoints(loopStart: number, loopEnd: number): this;
+    setParam(name: string, value: number): this;
+    applyParams(params: SamplerParamPatch): this;
+    /** PARAM GETTERS  */
+    getAudioParam(name: string): AudioParam | null;
+    getStartPoint(): number;
+    getEndPoint(): number;
+    getLoopRampDuration(): number;
+    getGlideTime(): number;
+    getHpfCutoff: () => number;
+    getLpfCutoff: () => number;
+    getParameterValue(name: string): number | undefined;
+    enablePitch: () => void;
+    disablePitch: () => void;
+    enableEnvelope: (envType: EnvelopeType) => void;
+    disableEnvelope: (envType: EnvelopeType) => void;
+    getEnvelope(envType: EnvelopeType): CustomEnvelope;
+    setEnvelopeLoop: (envType: EnvelopeType, loop: boolean, mode?: "normal" | "ping-pong" | "reverse") => void;
+    setEnvelopeSync: (envType: EnvelopeType, sync: boolean) => void;
+    setEnvelopeTimeScale: (envType: EnvelopeType, timeScale: number) => void;
+    setEnvelopeSustainPoint(envType: EnvelopeType, index: number | null): void;
+    setEnvelopeReleasePoint(envType: EnvelopeType, index: number): void;
+    updateEnvelopePoint(envType: EnvelopeType, index: number, time: number, value: number): void;
+    addEnvelopePoint(envType: EnvelopeType, time: number, value: number): void;
+    deleteEnvelopePoint(envType: EnvelopeType, index: number): void;
+    startLevelMonitoring(intervalMs?: number): void;
+    setDryWetMix: (mix: {
+        dry: number;
+        wet: number;
+    }) => void;
+    sendToFx: (effect: BusNodeName, amount: number) => void;
+    setLpfCutoff: (hz: number, preOrPostFx?: "pre" | "post") => void;
+    setHpfCutoff: (hz: number, preOrPostFx?: "pre" | "post") => void;
+    setReverbAmount: (amount: number) => void;
+    setFeedbackDecay(value: number): void;
+    setFeedbackLowpassCutoff(freqHz: number): void;
+    setFeedbackAmount: (amount: number) => void;
+    setFeedbackMode(mode: 'monophonic' | 'polyphonic' | 'double-trouble'): void;
+    setFeedbackPitchScale(value: number): void;
+    get mainOut(): GainNode;
+    get outputBus(): InstrumentBus;
+    get sampleDuration(): number;
+    get volume(): number;
+    set volume(value: number);
+    get loopEnabled(): boolean;
+    get holdEnabled(): boolean;
+    get gainLFO(): LFO | null;
+    get pitchLFO(): LFO | null;
+    get loopStart(): number;
+    get loopEnd(): number;
+    get isLoaded(): boolean;
+    get audiobuffer(): AudioBuffer | null;
+    dispose(): void;
+}
+
+export declare interface SamplerParamDescriptor {
+    label: string;
+    min: number;
+    max: number;
+    defaultValue: number;
+    /** UI taper hint: 1 = linear, >1 = more resolution at the low end */
+    curve?: number;
+    /** Snap increment for UI controls */
+    step?: number;
+    /** Discrete values only (e.g. pitch scale ratios) */
+    allowedValues?: readonly number[];
+    format?: (value: number, sampleDurationSeconds: number) => string;
+    apply: (player: SamplePlayer, value: number) => void;
+}
+
+export declare type SamplerParamKey = keyof typeof samplerParams;
+
+export declare type SamplerParamPatch = Partial<SamplerParamValues>;
+
+export declare const samplerParams: Record<"distortion" | "delayTime" | "feedback" | "feedbackDecay" | "drive" | "loopEnd" | "loopStart" | "volume" | "dryWet" | "glide" | "tempo" | "lowpassFilter" | "highpassFilter" | "feedbackPitch" | "feedbackLpf" | "clipping" | "amMod" | "reverbSend" | "reverbSize" | "delaySend" | "delayFeedback" | "gainLFORate" | "gainLFODepth" | "pitchLFORate" | "pitchLFODepth" | "trimStart" | "trimEnd" | "loopDuration" | "loopRampDuration" | "loopDurationDrift" | "keytrackLoop", SamplerParamDescriptor>;
+
+export declare type SamplerParamValues = Record<SamplerParamKey, number>;
+
+export declare interface SamplerToggleDescriptor {
+    label: string;
+    defaultValue: boolean;
+    format: (enabled: boolean) => string;
+    apply: (player: SamplePlayer, enabled: boolean) => void;
+}
+
+export declare type SamplerToggleKey = keyof typeof samplerToggles;
+
+export declare const samplerToggles: {
+    readonly timestretch: {
+        readonly label: "Timestretch";
+        readonly defaultValue: false;
+        readonly format: (enabled: boolean) => "Warp" | "RePitch";
+        readonly apply: (player: SamplePlayer, enabled: boolean) => SamplePlayer;
+    };
+    readonly panDrift: {
+        readonly label: "Pan drift";
+        readonly defaultValue: true;
+        readonly format: (enabled: boolean) => "◐" | "○";
+        readonly apply: (player: SamplePlayer, enabled: boolean) => SamplePlayer;
+    };
+    readonly feedbackMode: {
+        readonly label: "Feedback mode";
+        readonly defaultValue: true;
+        readonly format: (enabled: boolean) => "Poly" | "Mono";
+        readonly apply: (player: SamplePlayer, enabled: boolean) => void;
+    };
+    readonly gainLFOSync: {
+        readonly label: "Amp LFO sync";
+        readonly defaultValue: false;
+        readonly format: (enabled: boolean) => "Sync" | "Free";
+        readonly apply: (player: SamplePlayer, enabled: boolean) => void;
+    };
+    readonly pitchLFOSync: {
+        readonly label: "Pitch LFO sync";
+        readonly defaultValue: false;
+        readonly format: (enabled: boolean) => "Sync" | "Free";
+        readonly apply: (player: SamplePlayer, enabled: boolean) => void;
+    };
+};
+
+declare class SampleVoice {
+    #private;
+    private context;
+    readonly nodeId: NodeID_2;
+    readonly nodeType: NodeType;
+    constructor(context?: AudioContext, options?: {
+        processorOptions?: any;
+        enableFilters?: boolean;
+    });
+    init(): Promise<void>;
+    loadBuffer(buffer: AudioBuffer, zeroCrossings?: number[]): Promise<boolean>;
+    freeze(freeze: boolean): this;
+    setGlideTime(seconds: number): void;
+    trigger(options: {
+        midiNote: MidiValue;
+        velocity: MidiValue;
+        secondsFromNow?: number;
+        glide?: {
+            prevMidiNote: number;
+            glideTime?: number;
+        };
+    }): MidiValue | null;
+    applyEnvelopes(timestamp: number, playbackRate: number, velocity?: number, midiNote?: number): void;
+    release({ releaseTime, secondsFromNow }: {
+        releaseTime?: number | undefined;
+        secondsFromNow?: number | undefined;
+    }): this;
+    stop(timestamp?: number): this;
+    setModulationAmount(modType: 'AM' | 'FM', amount: number): this;
+    setModulationWaveform(modType?: 'AM' | 'FM', waveform?: CustomLibWaveform | OscillatorType | PeriodicWave, customWaveOptions?: WaveformOptions): this;
+    enableEnvelope: (envType: EnvelopeType) => void;
+    disableEnvelope: (envType: EnvelopeType) => void;
+    setEnvelopeTimeScale: (envType: EnvelopeType, timeScale: number) => void;
+    setEnvelopeSustainPoint: (envType: EnvelopeType, index: number | null) => void;
+    setEnvelopeReleasePoint: (envType: EnvelopeType, index: number) => void;
+    addEnvelopePoint(envType: EnvelopeType, time: number, value: number): void;
+    updateEnvelopePoint(envType: EnvelopeType, index: number, time?: number, value?: number): void;
+    deleteEnvelopePoint(envType: EnvelopeType, index: number): void;
+    getEnvelope: (envType: EnvelopeType) => CustomEnvelope | undefined;
+    get envelopes(): Map<EnvelopeType, CustomEnvelope>;
+    setStartPoint: (time: number, timestamp?: number) => void;
+    setEndPoint: (time: number, timestamp?: number) => void;
+    setParam(name: string, targetValue: number, timestamp?: number, options?: {
+        glideTime?: number;
+        cancelPrevious?: boolean;
+    }): this;
+    protected setParams(paramsAndValues: Array<{
+        name: string;
+        value: number;
+    }>, atTime: number, options?: {
+        glideTime?: number;
+        cancelPrevious?: boolean;
+    }): this;
+    setLoopPoints(start: number, end: number, timestamp?: number, rampTime?: number): this;
+    syncLoopToTempo(enabled: boolean): this;
+    setKeytrackLoopAmount(amount: number): this;
+    setTempo(bpm: number): this;
+    setAllowedPeriods(periods: number[]): this;
+    disablePitch: () => void;
+    enablePitch: () => void;
+    /** CONNECTIONS */
+    connect(destination: Destination, output?: number, input?: number): Destination;
+    disconnect(output?: string, destination?: Destination): this;
+    /** MESSAGES */
+    onMessage(type: string, handler: MessageHandler<Message>): () => void;
+    sendToProcessor(data: any): this;
+    sendUpstreamMessage(type: string, data: any): this;
+    getPlaybackDuration(): number;
+    get isActive(): boolean;
+    get feedback(): HarmonicFeedback | null;
+    get currMidiNote(): number | null;
+    get hpf(): BiquadFilterNode | null;
+    get lpf(): BiquadFilterNode | null;
+    get in(): null;
+    get out(): GainNode;
+    get state(): VoiceState;
+    get initialized(): boolean;
+    get now(): number;
+    get activeNoteId(): number | string | null;
+    get triggerTimestamp(): number;
+    get sampleDurationSeconds(): number;
+    get startPoint(): number;
+    get endPoint(): number;
+    get releaseTime(): number;
+    setMasterGain(gain: number): void;
+    enablePositionTracking(enabled: boolean): this;
+    setLoopEnabled(enabled: boolean): this;
+    setEnvelopeLoop: (envType: EnvelopeType, loop: boolean, mode?: "normal" | "ping-pong" | "reverse") => this;
+    syncEnvelopeToPlaybackRate: (envType: EnvelopeType, sync: boolean) => this;
+    setPlaybackRate(rate: number, atTime?: number, options?: {
+        glideTime?: number;
+        cancelPrevious?: boolean;
+    }): this;
+    setHpfCutoff(hz: number, atTime?: number, options?: {
+        glideTime?: number;
+        cancelPrevious?: boolean;
+    }): this;
+    setLpfCutoff(hz: number, atTime?: number, options?: {
+        glideTime?: number;
+        cancelPrevious?: boolean;
+    }): this;
+    setPlaybackDirection(direction: 'forward' | 'reverse'): this;
+    setLoopDurationDriftAmount(amount: number): this;
+    setPanDriftEnabled: (enabled: boolean) => this;
+    setTimestretchEnabled: (enabled: boolean) => this;
+    debugDuration(): void;
+    dispose(): void;
+    getParam(name: string): AudioParam | null;
+}
+
+declare class SampleVoicePool implements LibNode {
+    #private;
+    readonly nodeId: NodeID_2;
+    readonly nodeType = "pool";
+    constructor(context: AudioContext, polyphony: number);
+    init(): Promise<void>;
+    connect(destination: AudioNode): void;
+    disconnect(): void;
+    onMessage(type: string, handler: MessageHandler<Message>): () => void;
+    sendUpstreamMessage(type: string, data: any): this;
+    setBuffer(buffer: AudioBuffer, zeroCrossings?: number[]): this;
+    allocate(available?: Set<SampleVoice>, releasing?: Set<SampleVoice>): SampleVoice | undefined;
+    prevMidiNote: number;
+    noteOn(midiNote: MidiValue, velocity?: MidiValue, secondsFromNow?: number, glideTime?: number): MidiValue | null;
+    noteOff(midiNote: MidiValue, secondsFromNow?: number, releaseTime?: number): this | undefined;
+    allNotesOff(releaseTime?: number): this;
+    applyToAllVoices(fn: (voice: SampleVoice) => void): void;
+    applyToActiveVoices(fn: (voice: SampleVoice) => void): void;
+    applyToInactiveVoices(fn: (voice: SampleVoice) => void): void;
+    applyToActiveNote(midiNote: MidiValue, fn: (voice: SampleVoice) => void): void;
+    debug(): void;
+    dispose(): void;
+    get initialized(): boolean;
+    get availableVoices(): Set<SampleVoice>;
+    get playingVoicesCount(): number;
+    get releasingVoicesCount(): number;
+    get availableVoicesCount(): number;
+    get allVoices(): SampleVoice[];
+    get allVoicesCount(): number;
+    get assignedVoicesMidiMap(): Map<number, SampleVoice>;
+}
+
+declare const SCALE_PATTERNS: {
+    chromatic: number[];
+    major: number[];
+    minor: number[];
+    harmonic_minor: number[];
+    melodic_minor: number[];
+    lydian: number[];
+    dorian: number[];
+    phrygian: number[];
+    mixolydian: number[];
+    locrian: number[];
+    diminished: number[];
+    augmented: number[];
+    major_pentatonic: number[];
+    minor_pentatonic: number[];
+    blues: number[];
+    whole_tone: number[];
+};
+
+/** Routes the global AudioContext (all audiolib output) to the given output device.
+ *  Pass '' or 'default' to restore the system default output. */
+export declare function setAudioOutputDevice(deviceId: string): Promise<void>;
+
+declare type SetDelayCharacterMsg = {
+    type: 'setCharacter';
+    modes: DelayCharacter[];
+};
+
+/** All supported oscillator waveforms */
+export declare const SUPPORTED_WAVEFORMS: readonly SupportedWaveform[];
+
+/** Union type of all supported waveforms */
+export declare type SupportedWaveform = 'sine' | 'sawtooth' | 'square' | 'triangle' | CustomLibWaveform;
+
+declare type TriggerDelayMsg = {
+    type: 'trigger';
+};
+
+declare class ValueSnapper {
+    #private;
+    paramType: string | null;
+    setScale(rootNote: keyof typeof ROOT_NOTES, scalePattern: readonly number[] | number[], tuningOffset: number | undefined, // in semitones
+    lowestOctave: number | undefined, highestOctave: number | undefined, normalize: NormalizeOptions | false, snapToZeroCrossings?: number[] | false): number[];
+    setRootNote(rootNote: keyof typeof ROOT_NOTES): void;
+    setAllowedPeriods(periods: number[], normalize: NormalizeOptions | false, snapToZeroCrossings?: number[] | false, direction?: 'left' | 'right' | 'any'): number[];
+    snapToValue(target: number, allowedValues?: number[], tolerance?: number, preferDirection?: 'left' | 'right' | 'any'): number;
+    snapToMusicalPeriod(targetPeriod: number, allowedPeriods?: number[]): number;
+    setAllowedValues(values: number[], normalize: NormalizeOptions | false): number[];
+    get rootNote(): "C" | "C#" | "Db" | "D" | "D#" | "Eb" | "E" | "F" | "F#" | "Gb" | "G" | "G#" | "Ab" | "A" | "A#" | "Bb" | "B";
+    get scalePattern(): number[];
+    get periods(): number[];
+    get shortestPeriod(): number;
+    get longestPeriod(): number;
+    get hasValueSnapping(): boolean;
+    get hasPeriodSnapping(): boolean;
+}
+
+declare const VoiceState: {
+    readonly NOT_READY: "NOT_READY";
+    readonly LOADED: "LOADED";
+    readonly PLAYING: "PLAYING";
+    readonly RELEASING: "RELEASING";
+    readonly STOPPING: "STOPPING";
+    readonly STOPPED: "STOPPED";
+};
+
+declare type VoiceState = (typeof VoiceState)[keyof typeof VoiceState];
+
+declare type VoiceType = 'sample-voice' | 'karplus-strong-voice' | 'osc-voice' | 'noise-voice';
+
+/**
+ * Generic options interface that can be used with any CustomLibWaveform type
+ */
+declare interface WaveformOptions {
+    harmonics?: number;
+    seed?: number;
+    dutyCycle?: number;
+    rolloff?: number;
+    voices?: number;
+    detune?: number;
+    brightness?: number;
+    inharmonicity?: number;
+    formantFreqs?: number[];
+    formantBandwidths?: number[];
+    fundamentalFreq?: number;
+    slope?: number;
+    chaos?: number;
+    harmonicDensity?: number;
+    waveFunction?: (phase: number) => number;
+}
+
+declare interface WorkletConfig {
+    params: WorkletParameters;
+    message: WorkletMessage;
+}
+
+declare type WorkletMessage = Record<string, any>;
+
+declare class WorkletNode<TConfig extends WorkletConfig = DefaultWorkletConfig> extends AudioWorkletNode {
+    private _processorReady;
+    private _messageQueue;
+    constructor(audioContext: AudioContext, processorName: string, options?: AudioWorkletNodeOptions);
+    setParam<K extends keyof TConfig['params']>(name: K, value: TConfig['params'][K]): this;
+    getParam<K extends keyof TConfig['params']>(name: K): AudioParam | undefined;
+    sendProcessorMessage(message: TConfig['message']): this;
+    private _onProcessorMessage?;
+    onProcessorMessage(callback: (event: MessageEvent<TConfig['message']>) => void): this;
+    dispose(): void;
+}
+
+declare interface WorkletParameters {
+    [key: string]: number;
+}
+
+export { }