spessasynth_lib 3.27.8 → 4.0.1

package/dist/index.d.ts

@@ -0,0 +1,1328 @@
+import { BasicMIDI, MIDITrack, MIDIMessage, SequencerEvent, SpessaSynthProcessor, SpessaSynthSequencer, SynthProcessorOptions, BasicSoundBank, SoundFont2WriteOptions, DLSWriteOptions, RMIDIWriteOptions, SynthesizerSnapshot, SynthMethodOptions, CustomController, MIDIController, MasterParameterType, KeyModifier, SynthProcessorEvent, MIDIPatch, SoundBankManagerListEntry, SynthProcessorEventData, ChannelSnapshot, ChannelProperty, PresetList, WaveWriteOptions } from 'spessasynth_core';
+
+declare const songChangeType: {
+    readonly shuffleOn: 1;
+    readonly shuffleOff: 2;
+    readonly index: 3;
+};
+type SongChangeType = (typeof songChangeType)[keyof typeof songChangeType];
+
+declare class MIDIDataTrack extends MIDITrack {
+    /**
+     * THIS DATA WILL BE EMPTY! USE sequencer.getMIDI() TO GET THE ACTUAL DATA!
+     */
+    events: never[];
+    constructor(track: MIDITrack);
+}
+/**
+ * A simplified version of the MIDI, accessible at all times from the Sequencer.
+ * Use getMIDI() to get the actual sequence.
+ * This class contains all properties that MIDI does, except for tracks and the embedded sound bank.
+ */
+declare class MIDIData extends BasicMIDI {
+    tracks: MIDIDataTrack[];
+    /**
+     * THIS DATA WILL BE EMPTY! USE sequencer.getMIDI() TO GET THE ACTUAL DATA!
+     */
+    embeddedSoundBank: undefined;
+    /**
+     * The byte length of the sound bank if it exists.
+     */
+    readonly embeddedSoundBankSize?: number;
+    constructor(mid: BasicMIDI);
+}
+
+interface SequencerOptions {
+    /**
+     * If true, the sequencer will skip to the first note.
+     */
+    skipToFirstNoteOn: boolean;
+    /**
+     * The initial playback rate, defaults to 1.0 (normal speed).
+     */
+    initialPlaybackRate: number;
+}
+type SequencerMessage = {
+    [K in keyof SequencerMessageData]: {
+        type: K;
+        data: SequencerMessageData[K];
+    };
+}[keyof SequencerMessageData];
+interface SequencerMessageData {
+    loadNewSongList: SuppliedMIDIData[];
+    pause: null;
+    play: null;
+    setTime: number;
+    changeMIDIMessageSending: boolean;
+    setPlaybackRate: number;
+    setLoopCount: number;
+    changeSong: {
+        changeType: SongChangeType;
+        data?: number;
+    };
+    getMIDI: null;
+    setSkipToFirstNote: boolean;
+}
+type SequencerReturnMessage = SequencerEvent | {
+    type: "getMIDI";
+    data: BasicMIDI;
+} | {
+    type: "midiError";
+    data: Error;
+};
+/**
+ * Sequencer.js
+ * purpose: plays back the midi file decoded by midi_loader.js, including support for multichannel midis
+ * (adding channels when more than one midi port is detected)
+ * note: this is the sequencer class that runs on the main thread
+ * and only communicates with the worklet sequencer which does the actual playback
+ */
+type SuppliedMIDIData = BasicMIDI | {
+    /**
+     * The binary data of the file.
+     */
+    binary: ArrayBuffer;
+    /**
+     * The file name of this file as a fallback.
+     */
+    fileName?: string;
+};
+interface WorkletSequencerEventType {
+    /**
+     * New song.
+     */
+    songChange: MIDIData;
+    /**
+     * New time.
+     */
+    timeChange: number;
+    /**
+     * No data.
+     */
+    songEnded: null;
+    metaEvent: {
+        event: MIDIMessage;
+        trackNumber: number;
+    };
+    textEvent: {
+        /**
+         * The raw event.
+         */
+        event: MIDIMessage;
+        /**
+         * If the text is a lyric, the index of the lyric in BasicMIDI's "lyrics" property, otherwise -1.
+         */
+        lyricsIndex: number;
+    };
+    midiError: Error;
+}
+
+type PostMessageSynthCore = (data: BasicSynthesizerReturnMessage, transfer?: Transferable[]) => unknown;
+/**
+ * The interface for the audio processing code that uses spessasynth_core and runs on a separate thread.
+ */
+declare abstract class BasicSynthesizerCore {
+    readonly synthesizer: SpessaSynthProcessor;
+    readonly sequencer: SpessaSynthSequencer;
+    protected readonly post: PostMessageSynthCore;
+    /**
+     * Indicates if the processor is alive.
+     * @protected
+     */
+    protected alive: boolean;
+    protected constructor(sampleRate: number, options: SynthProcessorOptions, postMessage: PostMessageSynthCore);
+    protected postReady<K extends keyof SynthesizerReturn>(type: K, data: SynthesizerReturn[K], transferable?: Transferable[]): void;
+    protected postProgress<K extends keyof SynthesizerProgress>(type: K, data: SynthesizerProgress[K]): void;
+    protected destroy(): void;
+    protected handleMessage(m: BasicSynthesizerMessage): void;
+}
+
+declare class WorkerSynthesizerCore extends BasicSynthesizerCore {
+    /**
+     * The message port to the playback audio worklet.
+     */
+    readonly workletMessagePort: MessagePort;
+    protected readonly compressionFunction?: WorkerSampleEncodingFunction;
+    /**
+     * Creates a new worker synthesizer core: the synthesizer that runs in the worker.
+     * Most parameters here are provided with the first message that is posted to the worker by the WorkerSynthesizer.
+     * @param synthesizerConfiguration The data from the first message sent from WorkerSynthesizer.
+     * Listen for the first event and use its data to initialize this class.
+     * @param workletMessagePort The first port from the first message sent from WorkerSynthesizer.
+     * @param mainThreadCallback postMessage function or similar.
+     * @param compressionFunction Optional function for compressing SF3 banks.
+     */
+    constructor(synthesizerConfiguration: {
+        sampleRate: number;
+        initialTime: number;
+    }, workletMessagePort: MessagePort, mainThreadCallback: typeof Worker.prototype.postMessage, compressionFunction?: WorkerSampleEncodingFunction);
+    /**
+     * Handles a message received from the main thread.
+     * @param m The message received.
+     */
+    handleMessage(m: BasicSynthesizerMessage): void;
+    protected getBank(opts: WorkerBankWriteOptions): BasicSoundBank;
+    protected stopAudioLoop(): void;
+    protected startAudioLoop(): void;
+    protected destroy(): void;
+    protected renderAndSendChunk(): void;
+}
+
+interface WorkerRenderAudioOptions {
+    /**
+     * Extra fadeout time after the song finishes, in seconds.
+     */
+    extraTime: number;
+    /**
+     * If channels should be rendered separately.
+     */
+    separateChannels: boolean;
+    /**
+     * The amount of times to loop the song.
+     */
+    loopCount: number;
+    /**
+     * The function that tracks the rendering progress.
+     * @param progress mapped 0 to 1.
+     * @param stage 0 is a dry pass, 1 is adding effects.
+     */
+    progressCallback?: (progress: number, stage: number) => unknown;
+    /**
+     * If the current parameters of the synthesizer should be preserved.
+     */
+    preserveSynthParams: boolean;
+    /**
+     * If the effects should be enabled.
+     */
+    enableEffects: boolean;
+}
+
+interface PassedProcessorParameters {
+    /**
+     * If the synthesizer should send events.
+     */
+    enableEventSystem: boolean;
+    /**
+     * If the synth should use one output with 32 channels (2 audio channels for each midi channel).
+     */
+    oneOutput: boolean;
+}
+interface OfflineRenderWorkletData {
+    /**
+     * The MIDI to render.
+     */
+    midiSequence: BasicMIDI;
+    /**
+     * The snapshot to apply.
+     */
+    snapshot?: SynthesizerSnapshot;
+    /**
+     * The amount times to loop the song.
+     */
+    loopCount: number;
+    /**
+     * The list of sound banks to render this file with.
+     */
+    soundBankList: {
+        bankOffset: number;
+        soundBankBuffer: ArrayBuffer;
+    }[];
+    /**
+     * The options to pass to the sequencer.
+     */
+    sequencerOptions: Partial<SequencerOptions>;
+}
+interface WorkletSBKManagerData {
+    addSoundBank: {
+        soundBankBuffer: ArrayBuffer;
+        id: string;
+        bankOffset: number;
+    };
+    deleteSoundBank: string;
+    rearrangeSoundBanks: string[];
+}
+interface WorkletKMManagerData {
+    addMapping: {
+        channel: number;
+        midiNote: number;
+        mapping: KeyModifier;
+    };
+    deleteMapping: {
+        channel: number;
+        midiNote: number;
+    };
+    clearMappings: null;
+}
+type BasicSynthesizerMessage = {
+    [K in keyof BasicSynthesizerMessageData]: {
+        channelNumber: number;
+        type: K;
+        data: BasicSynthesizerMessageData[K];
+    };
+}[keyof BasicSynthesizerMessageData];
+interface WorkerBankWriteOptions {
+    /**
+     * Trim the sound bank to only include samples used in the current MIDI file.
+     */
+    trim: boolean;
+    /**
+     * The sound bank ID in the sound bank manager to write.
+     */
+    bankID: string;
+    /**
+     * If the embedded sound bank should be written instead if it exists.
+     */
+    writeEmbeddedSoundBank: boolean;
+}
+type WorkerDLSWriteOptions = Omit<DLSWriteOptions, "progressFunction"> & WorkerBankWriteOptions;
+type WorkerSoundFont2WriteOptions = Omit<SoundFont2WriteOptions, "compressionFunction" | "progressFunction"> & WorkerBankWriteOptions & {
+    /**
+     * The compression quality to call your provided compressionFunction with, if compressing.
+     */
+    compressionQuality: number;
+};
+type WorkerSampleEncodingFunction = (audioData: Float32Array, sampleRate: number, quality: number) => Promise<Uint8Array>;
+type WorkerRMIDIWriteOptions = Omit<RMIDIWriteOptions, "soundBank"> & (({
+    format: "sf2";
+} & WorkerSoundFont2WriteOptions) | ({
+    format: "dls";
+} & WorkerDLSWriteOptions));
+interface BasicSynthesizerMessageData {
+    workerInitialization: {
+        sampleRate: number;
+        currentTime: number;
+    };
+    renderAudio: {
+        sampleRate: number;
+        options: WorkerRenderAudioOptions;
+    };
+    writeSF2: WorkerSoundFont2WriteOptions;
+    writeDLS: WorkerDLSWriteOptions;
+    writeRMIDI: WorkerRMIDIWriteOptions;
+    startOfflineRender: OfflineRenderWorkletData;
+    midiMessage: {
+        messageData: Uint8Array;
+        channelOffset: number;
+        force: boolean;
+        options: SynthMethodOptions;
+    };
+    ccReset: null;
+    setChannelVibrato: {
+        rate: number;
+        depth: number;
+        delay: number;
+    };
+    stopAll: number;
+    killNotes: number;
+    muteChannel: boolean;
+    addNewChannel: null;
+    customCcChange: {
+        ccNumber: CustomController;
+        ccValue: number;
+    };
+    transposeChannel: {
+        semitones: number;
+        force: boolean;
+    };
+    setDrums: boolean;
+    lockController: {
+        controllerNumber: MIDIController | -1;
+        isLocked: boolean;
+    };
+    sequencerSpecific: SequencerMessage;
+    requestSynthesizerSnapshot: null;
+    setLogLevel: {
+        enableInfo: boolean;
+        enableWarning: boolean;
+        enableGroup: boolean;
+    };
+    setMasterParameter: {
+        [K in keyof MasterParameterType]: {
+            type: K;
+            data: MasterParameterType[K];
+        };
+    }[keyof MasterParameterType];
+    soundBankManager: {
+        [K in keyof WorkletSBKManagerData]: {
+            type: K;
+            data: WorkletSBKManagerData[K];
+        };
+    }[keyof WorkletSBKManagerData];
+    keyModifierManager: {
+        [K in keyof WorkletKMManagerData]: {
+            type: K;
+            data: WorkletKMManagerData[K];
+        };
+    }[keyof WorkletKMManagerData];
+    destroyWorklet: null;
+}
+interface BasicSynthesizerReturnMessageData {
+    eventCall: SynthProcessorEvent;
+    sequencerReturn: SequencerReturnMessage;
+    isFullyInitialized: {
+        [K in keyof SynthesizerReturn]: {
+            type: K;
+            data: SynthesizerReturn[K];
+        };
+    }[keyof SynthesizerReturn];
+    soundBankError: Error;
+    renderingProgress: {
+        [K in keyof SynthesizerProgress]: {
+            type: K;
+            data: SynthesizerProgress[K];
+        };
+    }[keyof SynthesizerProgress];
+}
+type BasicSynthesizerReturnMessage = {
+    [K in keyof BasicSynthesizerReturnMessageData]: {
+        type: K;
+        data: BasicSynthesizerReturnMessageData[K];
+        currentTime: number;
+    };
+}[keyof BasicSynthesizerReturnMessageData];
+interface SynthesizerProgress {
+    renderAudio: number;
+    workerSynthWriteFile: {
+        sampleName: string;
+        sampleIndex: number;
+        sampleCount: number;
+    };
+}
+interface SynthesizerReturn {
+    sf3Decoder: null;
+    soundBankManager: null;
+    startOfflineRender: null;
+    synthesizerSnapshot: SynthesizerSnapshot;
+    renderAudio: {
+        reverb: [Float32Array, Float32Array];
+        chorus: [Float32Array, Float32Array];
+        dry: [Float32Array, Float32Array][];
+    };
+    workerSynthWriteFile: {
+        /**
+         * The binary data of the file.
+         */
+        binary: ArrayBuffer;
+        /**
+         * The suggested name of the file.
+         */
+        fileName: string;
+    };
+}
+
+interface SynthConfig {
+    /**
+     * If the synth should use one output with 32 channels (2 audio channels for each midi channel).
+     */
+    oneOutput: boolean;
+    /**
+     * If the chorus processor should be initialized during creation.
+     * Note that setting this to false will not allow it to be used later.
+     * If you want to enable it at some point, set this to true and set the chorus gain to 0.
+     */
+    initializeChorusProcessor: boolean;
+    /**
+     * If the reverb processor should be initialized during creation.
+     * Note that setting this to false will not allow it to be used later.
+     * If you want to enable it at some point, set this to true and set the reverb gain to 0.
+     */
+    initializeReverbProcessor: boolean;
+    /**
+     * Custom audio node creation functions for Web Audio wrappers, such as standardized-audio-context.
+     * Pass undefined to use the Web Audio API.
+     */
+    audioNodeCreators?: AudioNodeCreators;
+    /**
+     * If the event system should be enabled. This can only be set once.
+     */
+    enableEventSystem: boolean;
+}
+interface BasicEffectConfig {
+    null?: null;
+}
+interface AudioNodeCreators {
+    /**
+     * A custom creator for an AudioWorkletNode.
+     * @param context
+     * @param workletName
+     * @param options
+     */
+    worklet: (context: BaseAudioContext, workletName: string, options?: AudioWorkletNodeOptions & {
+        processorOptions: PassedProcessorParameters;
+    }) => AudioWorkletNode;
+}
+interface ReverbConfig extends BasicEffectConfig {
+    /**
+     * The impulse response for the reverb. Pass undefined to use default one.
+     */
+    impulseResponse?: AudioBuffer;
+}
+interface ChorusConfig extends BasicEffectConfig {
+    /**
+     * The amount of delay nodes (for each channel) and the corresponding oscillators.
+     */
+    nodesAmount: number;
+    /**
+     * The initial delay, in seconds.
+     */
+    defaultDelay: number;
+    /**
+     * The difference between delays in the delay nodes.
+     */
+    delayVariation: number;
+    /**
+     * The difference of delays between two channels (added to the right channel).
+     */
+    stereoDifference: number;
+    /**
+     * The initial delay time oscillator frequency, in Hz.
+     */
+    oscillatorFrequency: number;
+    /**
+     * The difference between frequencies of oscillators, in Hz.
+     */
+    oscillatorFrequencyVariation: number;
+    /**
+     * How much will oscillator alter the delay in delay nodes, in seconds.
+     */
+    oscillatorGain: number;
+}
+
+declare class WorkletKeyModifierManagerWrapper {
+    private keyModifiers;
+    private synth;
+    constructor(synth: BasicSynthesizer);
+    /**
+     * Modifies a single key.
+     * @param channel The channel affected. Usually 0-15.
+     * @param midiNote The MIDI note to change. 0-127.
+     * @param options The key's modifiers.
+     */
+    addModifier(channel: number, midiNote: number, options: Partial<{
+        velocity: number;
+        patch: MIDIPatch;
+        gain: number;
+    }>): void;
+    /**
+     * Gets a key modifier.
+     * @param channel The channel affected. Usually 0-15.
+     * @param midiNote The MIDI note to change. 0-127.
+     * @returns The key modifier if it exists.
+     */
+    getModifier(channel: number, midiNote: number): KeyModifier | undefined;
+    /**
+     * Deletes a key modifier.
+     * @param channel The channel affected. Usually 0-15.
+     * @param midiNote The MIDI note to change. 0-127.
+     */
+    deleteModifier(channel: number, midiNote: number): void;
+    /**
+     * Clears ALL Modifiers
+     */
+    clearModifiers(): void;
+    private sendToWorklet;
+}
+
+type LibSBKManagerEntry = Omit<SoundBankManagerListEntry, "soundBank">;
+declare class SoundBankManager {
+    /**
+     * All the sound banks, ordered from the most important to the least.
+     */
+    soundBankList: LibSBKManagerEntry[];
+    private synth;
+    /**
+     * Creates a new instance of the sound bank manager.
+     */
+    constructor(synth: BasicSynthesizer);
+    /**
+     * The current sound bank priority order.
+     * @returns The IDs of the sound banks in the current order.
+     */
+    get priorityOrder(): string[];
+    /**
+     * Rearranges the sound banks in a given order.
+     * @param newList The order of sound banks, a list of identifiers, first overwrites second.
+     */
+    set priorityOrder(newList: string[]);
+    /**
+     * Adds a new sound bank buffer with a given ID.
+     * @param soundBankBuffer The sound bank's buffer
+     * @param id The sound bank's unique identifier.
+     * @param bankOffset The sound bank's bank offset. Default is 0.
+     */
+    addSoundBank(soundBankBuffer: ArrayBuffer, id: string, bankOffset?: number): Promise<void>;
+    /**
+     * Deletes a sound bank with the given ID.
+     * @param id The sound bank to delete.
+     */
+    deleteSoundBank(id: string): Promise<void>;
+    private awaitResponse;
+    private sendToWorklet;
+}
+
+type ProcessorEventCallback<T extends keyof SynthProcessorEventData> = (callbackData: SynthProcessorEventData[T]) => unknown;
+declare class SynthEventHandler {
+    /**
+     * The time delay before an event is called.
+     * Set to 0 to disable it.
+     */
+    timeDelay: number;
+    /**
+     * The main list of events.
+     * @private
+     */
+    private readonly events;
+    /**
+     * Adds a new event listener.
+     * @param event The event to listen to.
+     * @param id The unique identifier for the event. It can be used to overwrite existing callback with the same ID.
+     * @param callback The callback for the event.
+     */
+    addEvent<T extends keyof SynthProcessorEventData>(event: T, id: string, callback: ProcessorEventCallback<T>): void;
+    /**
+     * Removes an event listener
+     * @param name The event to remove a listener from.
+     * @param id The unique identifier for the event to remove.
+     */
+    removeEvent<T extends keyof SynthProcessorEventData>(name: T, id: string): void;
+    /**
+     * Calls the given event.
+     * INTERNAL USE ONLY!
+     */
+    callEventInternal<T extends keyof SynthProcessorEventData>(name: T, eventData: SynthProcessorEventData[T]): void;
+}
+
+declare abstract class BasicEffectsProcessor {
+    readonly input: AudioNode;
+    protected readonly output: AudioNode;
+    protected constructor(input: AudioNode, output: AudioNode);
+    abstract get config(): BasicEffectConfig;
+    abstract update(config: BasicEffectConfig): void;
+    /**
+     * Connects the processor to a given node.
+     * @param destinationNode The node to connect to.
+     */
+    connect(destinationNode: AudioNode): AudioNode;
+    /**
+     * Disconnects the processor from a given node.
+     * @param destinationNode The node to disconnect from.
+     */
+    disconnect(destinationNode?: AudioNode): void;
+    /**
+     * Disconnects the effect processor.
+     */
+    delete(): void;
+}
+
+/**
+ * Fancy_chorus.js
+ * purpose: creates a simple chorus effect node
+ */
+
+declare class ChorusProcessor extends BasicEffectsProcessor {
+    private readonly chorusLeft;
+    private readonly chorusRight;
+    /**
+     * Creates a fancy chorus effect.
+     * @param context The audio context.
+     * @param config The configuration for the chorus.
+     */
+    constructor(context: BaseAudioContext, config?: Partial<ChorusConfig>);
+    private _config;
+    get config(): ChorusConfig;
+    /**
+     * Updates the chorus with a given config.
+     * @param chorusConfig The config to use.
+     */
+    update(chorusConfig: Partial<ChorusConfig>): void;
+    /**
+     * Disconnects and deletes the chorus effect.
+     */
+    delete(): void;
+    private deleteNodes;
+    private createChorusNode;
+}
+
+declare class ReverbProcessor extends BasicEffectsProcessor {
+    /**
+     * Indicates that the reverb is ready.
+     */
+    readonly isReady: Promise<AudioBuffer>;
+    private conv;
+    /**
+     * Creates a new reverb processor.
+     * @param context The context to use.
+     * @param config The reverb configuration.
+     */
+    constructor(context: BaseAudioContext, config?: Partial<ReverbConfig>);
+    private _config;
+    get config(): ReverbConfig;
+    /**
+     * Updates the reverb with a given config.
+     * @param config The config to use.
+     */
+    update(config: Partial<ReverbConfig>): void;
+}
+
+declare class LibSynthesizerSnapshot extends SynthesizerSnapshot {
+    chorusConfig: ChorusConfig;
+    reverbConfig: ReverbConfig;
+    constructor(channelSnapshots: ChannelSnapshot[], masterParameters: MasterParameterType, keyMappings: (KeyModifier | undefined)[][], chorusConfig?: ChorusConfig, reverbConfig?: ReverbConfig);
+    /**
+     * Retrieves the spessasynth_core snapshot from the lib snapshot.
+     */
+    getCoreSnapshot(): SynthesizerSnapshot;
+}
+
+declare abstract class BasicSynthesizer {
+    /**
+     * Allows managing the sound bank list.
+     */
+    readonly soundBankManager: SoundBankManager;
+    /**
+     * Allows managing key modifications.
+     */
+    readonly keyModifierManager: WorkletKeyModifierManagerWrapper;
+    /**
+     * Allows setting up custom event listeners for the synthesizer.
+     */
+    readonly eventHandler: SynthEventHandler;
+    /**
+     * Synthesizer's parent AudioContext instance.
+     */
+    readonly context: BaseAudioContext;
+    /**
+     * Synth's current channel properties.
+     */
+    readonly channelProperties: ChannelProperty[];
+    /**
+     * The current preset list.
+     */
+    presetList: PresetList;
+    sequencerCallbackFunction?: (m: SequencerReturnMessage) => unknown;
+    /**
+     * Resolves when the synthesizer is ready.
+     */
+    readonly isReady: Promise<unknown>;
+    /**
+     * Synthesizer's reverb processor.
+     * Undefined if reverb is disabled.
+     */
+    readonly reverbProcessor?: ReverbProcessor;
+    /**
+     * Synthesizer's chorus processor.
+     * Undefined if chorus is disabled.
+     */
+    readonly chorusProcessor?: ChorusProcessor;
+    readonly post: (data: BasicSynthesizerMessage, transfer?: Transferable[]) => unknown;
+    protected readonly worklet: AudioWorkletNode;
+    /**
+     * The new channels will have their audio sent to the modulated output by this constant.
+     * what does that mean?
+     * e.g., if outputsAmount is 16, then channel's 16 audio data will be sent to channel 0
+     */
+    protected readonly _outputsAmount = 16;
+    /**
+     * The current amount of MIDI channels the synthesizer has.
+     */
+    channelsAmount: number;
+    protected readonly masterParameters: MasterParameterType;
+    protected resolveMap: Map<keyof SynthesizerReturn, (data: SynthesizerReturn[keyof SynthesizerReturn]) => unknown>;
+    protected renderingProgressTracker: Map<keyof SynthesizerProgress, ((args: number) => unknown) | ((args: {
+        sampleName: string;
+        sampleIndex: number;
+        sampleCount: number;
+    }) => unknown)>;
+    /**
+     * Creates a new instance of a synthesizer.
+     * @param worklet The AudioWorkletNode to use.
+     * @param postFunction The internal post function.
+     * @param config Optional configuration for the synthesizer.
+     */
+    protected constructor(worklet: AudioWorkletNode, postFunction: (data: BasicSynthesizerMessage, transfer?: Transferable[]) => unknown, config: SynthConfig);
+    /**
+     * Current voice amount
+     */
+    protected _voicesAmount: number;
+    /**
+     * The current number of voices playing.
+     */
+    get voicesAmount(): number;
+    /**
+     * The audioContext's current time.
+     */
+    get currentTime(): number;
+    /**
+     * Connects from a given node.
+     * @param destinationNode The node to connect to.
+     */
+    connect(destinationNode: AudioNode): AudioNode;
+    /**
+     * Disconnects from a given node.
+     * @param destinationNode The node to disconnect from.
+     */
+    disconnect(destinationNode?: AudioNode): AudioNode | undefined;
+    /**
+     * Sets the SpessaSynth's log level in the processor.
+     * @param enableInfo Enable info (verbose)
+     * @param enableWarning Enable warnings (unrecognized messages)
+     * @param enableGroup Enable groups (to group a lot of logs)
+     */
+    setLogLevel(enableInfo: boolean, enableWarning: boolean, enableGroup: boolean): void;
+    /**
+     * Gets a master parameter from the synthesizer.
+     * @param type The parameter to get.
+     * @returns The parameter value.
+     */
+    getMasterParameter<K extends keyof MasterParameterType>(type: K): MasterParameterType[K];
+    /**
+     * Sets a master parameter to a given value.
+     * @param type The parameter to set.
+     * @param value The value to set.
+     */
+    setMasterParameter<K extends keyof MasterParameterType>(type: K, value: MasterParameterType[K]): void;
+    /**
+     * Gets a complete snapshot of the synthesizer, effects.
+     */
+    getSnapshot(): Promise<LibSynthesizerSnapshot>;
+    /**
+     * Adds a new channel to the synthesizer.
+     */
+    addNewChannel(): void;
+    /**
+     * Sets custom vibrato for the channel.
+     * @param channel The channel number.
+     * @param value The vibrato parameters.
+     */
+    setVibrato(channel: number, value: {
+        delay: number;
+        depth: number;
+        rate: number;
+    }): void;
+    /**
+     * Connects the individual audio outputs to the given audio nodes. In the app, it's used by the renderer.
+     * @param audioNodes Exactly 16 outputs.
+     */
+    connectIndividualOutputs(audioNodes: AudioNode[]): void;
+    /**
+     * Disconnects the individual audio outputs to the given audio nodes. In the app, it's used by the renderer.
+     * @param audioNodes Exactly 16 outputs.
+     */
+    disconnectIndividualOutputs(audioNodes: AudioNode[]): void;
+    /**
+     * Disables the GS NRPN parameters like vibrato or drum key tuning.
+     */
+    disableGSNPRNParams(): void;
+    /**
+     * Sends a raw MIDI message to the synthesizer.
+     * @param message the midi message, each number is a byte.
+     * @param channelOffset the channel offset of the message.
+     * @param eventOptions additional options for this command.
+     */
+    sendMessage(message: Iterable<number>, channelOffset?: number, eventOptions?: SynthMethodOptions): void;
+    /**
+     * Starts playing a note
+     * @param channel Usually 0-15: the channel to play the note.
+     * @param midiNote 0-127 the key number of the note.
+     * @param velocity 0-127 the velocity of the note (generally controls loudness).
+     * @param eventOptions Additional options for this command.
+     */
+    noteOn(channel: number, midiNote: number, velocity: number, eventOptions?: SynthMethodOptions): void;
+    /**
+     * Stops playing a note.
+     * @param channel Usually 0-15: the channel of the note.
+     * @param midiNote {number} 0-127 the key number of the note.
+     * @param force Instantly kills the note if true.
+     * @param eventOptions Additional options for this command.
+     */
+    noteOff(channel: number, midiNote: number, force?: boolean, eventOptions?: SynthMethodOptions): void;
+    /**
+     * Stops all notes.
+     * @param force If the notes should immediately be stopped, defaults to false.
+     */
+    stopAll(force?: boolean): void;
+    /**
+     * Changes the given controller
+     * @param channel Usually 0-15: the channel to change the controller.
+     * @param controllerNumber 0-127 the MIDI CC number.
+     * @param controllerValue 0-127 the controller value.
+     * @param force Forces the controller-change message, even if it's locked or gm system is set and the cc is bank select.
+     * @param eventOptions Additional options for this command.
+     */
+    controllerChange(channel: number, controllerNumber: MIDIController, controllerValue: number, force?: boolean, eventOptions?: SynthMethodOptions): void;
+    /**
+     * Resets all controllers (for every channel)
+     */
+    resetControllers(): void;
+    /**
+     * Causes the given midi channel to ignore controller messages for the given controller number.
+     * @param channel Usually 0-15: the channel to lock.
+     * @param controllerNumber 0-127 MIDI CC number.
+     * @param isLocked True if locked, false if unlocked.
+     * @remarks
+     *  Controller number -1 locks the preset.
+     */
+    lockController(channel: number, controllerNumber: MIDIController | -1, isLocked: boolean): void;
+    /**
+     * Applies pressure to a given channel.
+     * @param channel Usually 0-15: the channel to change the controller.
+     * @param pressure 0-127: the pressure to apply.
+     * @param eventOptions Additional options for this command.
+     */
+    channelPressure(channel: number, pressure: number, eventOptions?: SynthMethodOptions): void;
+    /**
+     * Applies pressure to a given note.
+     * @param channel Usually 0-15: the channel to change the controller.
+     * @param midiNote 0-127: the MIDI note.
+     * @param pressure 0-127: the pressure to apply.
+     * @param eventOptions Additional options for this command.
+     */
+    polyPressure(channel: number, midiNote: number, pressure: number, eventOptions?: SynthMethodOptions): void;
+    /**
+     * Sets the pitch of the given channel.
+     * @param channel Usually 0-15: the channel to change pitch.
+     * @param value The bend of the MIDI pitch wheel message. 0 - 16384
+     * @param eventOptions Additional options for this command.
+     */
+    pitchWheel(channel: number, value: number, eventOptions?: SynthMethodOptions): void;
+    /**
+     * Sets the channel's pitch wheel range, in semitones.
+     * @param channel Usually 0-15: the channel to change.
+     * @param range The bend range in semitones.
+     */
+    pitchWheelRange(channel: number, range: number): void;
+    /**
+     * Changes the program for a given channel
+     * @param channel Usually 0-15: the channel to change.
+     * @param programNumber 0-127 the MIDI patch number.
+     * defaults to false
+     */
+    programChange(channel: number, programNumber: number): void;
+    /**
+     * Transposes the channel by given number of semitones.
+     * @param channel The channel number.
+     * @param semitones The transposition of the channel, it can be a float.
+     * @param force Defaults to false, if true transposes the channel even if it's a drum channel.
+     */
+    transposeChannel(channel: number, semitones: number, force?: boolean): void;
+    /**
+     * Mutes or unmutes the given channel.
+     * @param channel Usually 0-15: the channel to mute.
+     * @param isMuted Indicates if the channel is muted.
+     */
+    muteChannel(channel: number, isMuted: boolean): void;
+    /**
+     * Sends a MIDI Sysex message to the synthesizer.
+     * @param messageData The message's data, excluding the F0 byte, but including the F7 at the end.
+     * @param channelOffset Channel offset for the system exclusive message, defaults to zero.
+     * @param eventOptions Additional options for this command.
+     */
+    systemExclusive(messageData: number[] | Iterable<number> | Uint8Array, channelOffset?: number, eventOptions?: SynthMethodOptions): void;
+    /**
+     * Tune MIDI keys of a given program using the MIDI Tuning Standard.
+     * @param program  0 - 127 the MIDI program number to use.
+     * @param tunings The keys and their tunings.
+     * TargetPitch of -1 sets the tuning for this key to be tuned regularly.
+     */
+    tuneKeys(program: number, tunings: {
+        sourceKey: number;
+        targetPitch: number;
+    }[]): void;
+    /**
+     * Toggles drums on a given channel.
+     * @param channel The channel number.
+     * @param isDrum If the channel should be drums.
+     */
+    setDrums(channel: number, isDrum: boolean): void;
+    /**
+     * Yes please!
+     */
+    reverbateEverythingBecauseWhyNot(): "That's the spirit!";
+    /**
+     * INTERNAL USE ONLY!
+     * @param type INTERNAL USE ONLY!
+     * @param resolve INTERNAL USE ONLY!
+     */
+    awaitWorkerResponse<K extends keyof SynthesizerReturn>(type: K, resolve: (data: SynthesizerReturn[K]) => unknown): void;
+    protected assignProgressTracker<K extends keyof SynthesizerProgress>(type: K, progressFunction: (args: SynthesizerProgress[K]) => unknown): void;
+    protected revokeProgressTracker<K extends keyof SynthesizerProgress>(type: K): void;
+    protected _sendInternal(message: Iterable<number>, channelOffset: number, force: boolean | undefined, eventOptions: Partial<SynthMethodOptions>): void;
+    /**
+     * Handles the messages received from the worklet.
+     */
+    protected handleMessage(m: BasicSynthesizerReturnMessage): void;
+    protected addNewChannelInternal(post: boolean): void;
+    protected workletResponds<K extends keyof SynthesizerReturn>(type: K, data: SynthesizerReturn[K]): void;
+}
+
+/**
+ * This synthesizer uses an audio worklet node containing the processor.
+ */
+declare class WorkletSynthesizer extends BasicSynthesizer {
+    /**
+     * Creates a new instance of an AudioWorklet-based synthesizer.
+     * @param context The audio context.
+     * @param config Optional configuration for the synthesizer.
+     */
+    constructor(context: BaseAudioContext, config?: Partial<SynthConfig>);
+    /**
+     * Starts an offline audio render.
+     * @param config The configuration to use.
+     * @remarks
+     * Call this method immediately after you've set up the synthesizer.
+     * Do NOT call any other methods after initializing before this one.
+     * Chromium seems to ignore worklet messages for OfflineAudioContext.
+     */
+    startOfflineRender(config: OfflineRenderWorkletData): Promise<void>;
+    /**
+     * Destroys the synthesizer instance.
+     */
+    destroy(): void;
+}
+
+type WorkerSynthWriteOptions<K> = K & {
+    progressFunction?: (args: SynthesizerProgress["workerSynthWriteFile"]) => unknown;
+};
+/**
+ * This synthesizer uses a Worker containing the processor and an audio worklet node for playback.
+ */
+declare class WorkerSynthesizer extends BasicSynthesizer {
+    /**
+     * Time offset for syncing with the synth
+     * @private
+     */
+    private timeOffset;
+    /**
+     * Creates a new instance of a Worker-based synthesizer.
+     * @param context The audio context.
+     * @param workerPostMessage The postMessage for the worker containing the synthesizer core.
+     * @param config Optional configuration for the synthesizer.
+     */
+    constructor(context: BaseAudioContext, workerPostMessage: typeof Worker.prototype.postMessage, config?: Partial<SynthConfig>);
+    get currentTime(): number;
+    /**
+     * Registers an audio worklet for the WorkerSynthesizer.
+     * @param context The context to register the worklet for.
+     * @param maxQueueSize The maximum amount of 128-sample chunks to store in the worklet. Higher values result in less breakups but higher latency.
+     */
+    static registerPlaybackWorklet(context: BaseAudioContext, maxQueueSize?: number): Promise<void>;
+    /**
+     * Handles a return message from the Worker.
+     * @param e The event received from the Worker.
+     */
+    handleWorkerMessage(e: BasicSynthesizerReturnMessage): void;
+    /**
+     * Writes a DLS file directly in the worker.
+     * @param options Options for writing the file.
+     * @returns The file array buffer and its corresponding name.
+     */
+    writeDLS(options?: Partial<WorkerSynthWriteOptions<WorkerDLSWriteOptions>>): Promise<SynthesizerReturn["workerSynthWriteFile"]>;
+    /**
+     * Writes an SF2/SF3 file directly in the worker.
+     * @param options Options for writing the file.
+     * @returns The file array buffer and its corresponding name.
+     */
+    writeSF2(options?: Partial<WorkerSynthWriteOptions<WorkerSoundFont2WriteOptions>>): Promise<SynthesizerReturn["workerSynthWriteFile"]>;
+    /**
+     * Writes an embedded MIDI (RMIDI) file directly in the worker.
+     * @param options Options for writing the file.
+     * @returns The file array buffer.
+     */
+    writeRMIDI(options?: Partial<WorkerSynthWriteOptions<WorkerRMIDIWriteOptions>>): Promise<ArrayBuffer>;
+    /**
+     * Renders the current song in the connected sequencer to Float32 buffers.
+     * @param sampleRate The sample rate to use, in Hertz.
+     * @param renderOptions Extra options for the render.
+     * @returns A single audioBuffer if separate channels were not enabled, otherwise 16.
+     * @remarks
+     * This stops the synthesizer.
+     */
+    renderAudio(sampleRate: number, renderOptions?: Partial<WorkerRenderAudioOptions>): Promise<AudioBuffer[]>;
+}
+
+type SequencerEventCallback<T extends keyof WorkletSequencerEventType> = (callbackData: WorkletSequencerEventType[T]) => unknown;
+declare class SeqEventHandler {
+    /**
+     * The time delay before an event is called.
+     * Set to 0 to disable it.
+     */
+    timeDelay: number;
+    private readonly events;
+    /**
+     * Adds a new event listener.
+     * @param event The event to listen to.
+     * @param id The unique identifier for the event. It can be used to overwrite existing callback with the same ID.
+     * @param callback The callback for the event.
+     */
+    addEvent<T extends keyof WorkletSequencerEventType>(event: T, id: string, callback: SequencerEventCallback<T>): void;
+    /**
+     * Removes an event listener
+     * @param name The event to remove a listener from.
+     * @param id The unique identifier for the event to remove.
+     */
+    removeEvent<T extends keyof WorkletSequencerEventType>(name: T, id: string): void;
+    /**
+     * Calls the given event.
+     * Internal use only.
+     */
+    callEventInternal<T extends keyof WorkletSequencerEventType>(name: T, eventData: WorkletSequencerEventType[T]): void;
+}
+
+declare class Sequencer {
+    /**
+     * The current MIDI data, with the exclusion of the embedded sound bank and event data.
+     */
+    midiData?: MIDIData;
+    /**
+     * The current MIDI data for all songs, like the midiData property.
+     */
+    songListData: MIDIData[];
+    /**
+     * Allows setting up custom event listeners for the sequencer.
+     */
+    eventHandler: SeqEventHandler;
+    /**
+     * Indicates whether the sequencer has finished playing a sequence.
+     */
+    isFinished: boolean;
+    /**
+     * The synthesizer attached to this sequencer.
+     */
+    readonly synth: BasicSynthesizer;
+    /**
+     * The MIDI port to play to.
+     */
+    private midiOut?;
+    private isLoading;
+    /**
+     * Indicates if the sequencer is paused.
+     * Paused if a number, undefined if playing.
+     */
+    private pausedTime?;
+    private getMIDICallback?;
+    private highResTimeOffset;
+    /**
+     * Absolute playback startTime, bases on the synth's time.
+     */
+    private absoluteStartTime;
+    /**
+     * Creates a new MIDI sequencer for playing back MIDI files.
+     * @param synth synth to send events to.
+     * @param options the sequencer's options.
+     */
+    constructor(synth: BasicSynthesizer, options?: Partial<SequencerOptions>);
+    private _songIndex;
+    /**
+     * The current song number in the playlist.
+     */
+    get songIndex(): number;
+    /**
+     * The current song number in the playlist.
+     */
+    set songIndex(value: number);
+    protected _currentTempo: number;
+    /**
+     * Current song's tempo in BPM.
+     */
+    get currentTempo(): number;
+    /**
+     * The current sequence's length, in seconds.
+     */
+    get duration(): number;
+    protected _songsAmount: number;
+    get songsAmount(): number;
+    protected _skipToFirstNoteOn: boolean;
+    /**
+     * Indicates if the sequencer should skip to first note on.
+     */
+    get skipToFirstNoteOn(): boolean;
+    /**
+     * Indicates if the sequencer should skip to first note on.
+     */
+    set skipToFirstNoteOn(val: boolean);
+    /**
+     * Internal loop count marker (-1 is infinite).
+     */
+    protected _loopCount: number;
+    /**
+     * The current remaining number of loops. -1 means infinite looping.
+     */
+    get loopCount(): number;
+    /**
+     * The current remaining number of loops. -1 means infinite looping.
+     */
+    set loopCount(val: number);
+    /**
+     * Controls the playback's rate.
+     */
+    protected _playbackRate: number;
+    /**
+     * Controls the playback's rate.
+     */
+    get playbackRate(): number;
+    /**
+     * Controls the playback's rate.
+     */
+    set playbackRate(value: number);
+    protected _shuffleSongs: boolean;
+    /**
+     * Indicates if the song order is random.
+     */
+    get shuffleSongs(): boolean;
+    /**
+     * Indicates if the song order is random.
+     */
+    set shuffleSongs(value: boolean);
+    /**
+     * Current playback time, in seconds.
+     */
+    get currentTime(): number;
+    /**
+     * Current playback time, in seconds.
+     */
+    set currentTime(time: number);
+    /**
+     * A smoothed version of currentTime.
+     * Use for visualization as it's not affected by the audioContext stutter.
+     */
+    get currentHighResolutionTime(): number;
+    /**
+     * True if paused, false if playing or stopped.
+     */
+    get paused(): boolean;
+    /**
+     * Gets the current MIDI File.
+     */
+    getMIDI(): Promise<BasicMIDI>;
+    /**
+     * Loads a new song list.
+     * @param midiBuffers The MIDI files to play.
+     */
+    loadNewSongList(midiBuffers: SuppliedMIDIData[]): void;
+    /**
+     * Connects a given output to the sequencer.
+     * @param output The output to connect. Pass undefined to use the connected synthesizer.
+     */
+    connectMIDIOutput(output?: MIDIOutput): void;
+    /**
+     * Pauses the playback.
+     */
+    pause(): void;
+    /**
+     * Starts or resumes the playback.
+     */
+    play(): void;
+    protected handleMessage(m: SequencerReturnMessage): void;
+    protected callEventInternal<EventType extends keyof WorkletSequencerEventType>(type: EventType, data: WorkletSequencerEventType[EventType]): void;
+    protected resetMIDIOutput(): void;
+    private recalculateStartTime;
+    private sendMessage;
+}
+
+interface ExtraWaveOptions extends WaveWriteOptions {
+    /**
+     * The channel offset in the AudioBuffer. Defaults to 0.
+     */
+    channelOffset: number;
+    /**
+     * The amount of channels from the AudioBuffer to write. Defaults to all.
+     */
+    channelCount: number;
+}
+/**
+ * Converts an audio buffer into a wave file.
+ * @param audioBuffer The audio data channels.
+ * @param options Additional options for writing the file.
+ * @returns The binary file.
+ */
+declare function audioBufferToWav(audioBuffer: AudioBuffer, options?: Partial<ExtraWaveOptions>): Blob;
+
+/**
+ * Midi_handler.js
+ * purpose: handles the connection between MIDI devices and synthesizer/sequencer via Web MIDI API
+ */
+declare class LibMIDIPort {
+    readonly port: MIDIPort;
+    protected constructor(port: MIDIPort);
+    /**
+     *
+     */
+    get id(): string;
+    /**
+     *
+     */
+    get name(): string | null;
+    /**
+     *
+     */
+    get manufacturer(): string | null;
+    /**
+     *
+     */
+    get version(): string | null;
+}
+declare class LibMIDIInput extends LibMIDIPort {
+    private readonly connectedSynths;
+    constructor(input: MIDIInput);
+    /**
+     * Connects the input to a given synth, listening for all incoming events.
+     * @param synth The synth to connect to.
+     */
+    connect(synth: BasicSynthesizer): void;
+    /**
+     * Disconnects the input from a given synth.
+     * @param synth The synth to disconnect from.
+     */
+    disconnect(synth: BasicSynthesizer): void;
+}
+declare class LibMIDIOutput extends LibMIDIPort {
+    readonly port: MIDIOutput;
+    constructor(output: MIDIOutput);
+    /**
+     * Connects a given sequencer to the output, playing back the MIDI file to it.
+     * @param seq The sequencer to connect.
+     */
+    connect(seq: Sequencer): void;
+    /**
+     * Disconnects sequencer from the output, making it play to the attached Synthesizer instead.
+     * @param seq The sequencer to disconnect.
+     */
+    disconnect(seq: Sequencer): void;
+}
+/**
+ * A class for handling physical MIDI devices.
+ */
+declare class MIDIDeviceHandler {
+    /**
+     * The available MIDI inputs. ID maps to the input.
+     */
+    readonly inputs: Map<string, LibMIDIInput>;
+    /**
+     * The available MIDI outputs. ID maps to the output.
+     */
+    readonly outputs: Map<string, LibMIDIOutput>;
+    private constructor();
+    /**
+     * Attempts to initialize the MIDI Device Handler.
+     * @returns The handler.
+     * @throws An error if the MIDI Devices fail to initialize.
+     */
+    static createMIDIDeviceHandler(): Promise<MIDIDeviceHandler>;
+}
+
+/**
+ * Web_midi_link.js
+ * purpose: handles the web midi link connection to the synthesizer
+ * https://www.g200kg.com/en/docs/webmidilink/
+ */
+declare class WebMIDILinkHandler {
+    /**
+     * Initializes support for Web MIDI Link (https://www.g200kg.com/en/docs/webmidilink/)
+     * @param synth The synthesizer to enable support with.
+     */
+    constructor(synth: BasicSynthesizer);
+}
+
+declare const DEFAULT_SYNTH_CONFIG: SynthConfig;
+
+export { ChorusProcessor, DEFAULT_SYNTH_CONFIG, MIDIDeviceHandler, ReverbProcessor, Sequencer, WebMIDILinkHandler, WorkerSynthesizer, WorkerSynthesizerCore, WorkletSynthesizer, audioBufferToWav };