spessasynth_core 4.2.6 → 4.2.8

package/dist/index.d.ts

@@ -624,1785 +624,1797 @@ declare class MIDIPatchTools {
     static sorter(a: MIDIPatch, b: MIDIPatch): number;
 }
 
-/**
- * Represents a cached voice
- */
-declare class CachedVoice {
+declare class Generator {
     /**
-     * Sample data of this voice.
+     * The generator's SF2 type.
      */
-    readonly sampleData: Float32Array;
+    generatorType: GeneratorType;
     /**
-     * The unmodulated (copied to) generators of the voice.
+     * The generator's 16-bit value.
      */
-    readonly generators: Int16Array;
+    generatorValue: number;
     /**
-     * The voice's modulators.
+     * Constructs a new generator
+     * @param type generator type
+     * @param value generator value
+     * @param validate if the limits should be validated and clamped.
      */
-    readonly modulators: Modulator[];
+    constructor(type: GeneratorType, value: number, validate?: boolean);
+    write(genData: IndexedByteArray): void;
+    toString(): string;
+}
+
+declare class BasicZone {
     /**
-     * Exclusive class number for hi-hats etc.
+     * The zone's velocity range.
+     * min -1 means that it is a default value
      */
-    readonly exclusiveClass: number;
+    velRange: GenericRange;
     /**
-     * Target key of the voice (can be overridden by generators)
+     * The zone's key range.
+     * min -1 means that it is a default value.
      */
-    readonly targetKey: number;
+    keyRange: GenericRange;
     /**
-     * Target velocity of the voice (can be overridden by generators)
+     * The zone's generators.
      */
-    readonly velocity: number;
+    generators: Generator[];
     /**
-     * MIDI root key of the sample
+     * The zone's modulators.
      */
-    readonly rootKey: number;
+    modulators: Modulator[];
+    get hasKeyRange(): boolean;
+    get hasVelRange(): boolean;
     /**
-     * Start position of the loop
+     * The current tuning in cents, taking in both coarse and fine generators.
      */
-    readonly loopStart: number;
+    get fineTuning(): number;
     /**
-     * End position of the loop
+     * The current tuning in cents, taking in both coarse and fine generators.
      */
-    readonly loopEnd: number;
+    set fineTuning(tuningCents: number);
     /**
-     * Playback step (rate) for sample pitch correction
+     * Adds to a given generator, or its default value.
+     * @param type the generator type.
+     * @param value the value to add.
+     * @param validate if the value should be clamped to allowed limits.
      */
-    readonly playbackStep: number;
-    readonly loopingMode: SampleLoopingMode;
-    constructor(voiceParams: VoiceParameters, midiNote: number, velocity: number, sampleRate: number);
-}
-
-declare const midiMessageTypes: {
-    readonly noteOff: 128;
-    readonly noteOn: 144;
-    readonly polyPressure: 160;
-    readonly controllerChange: 176;
-    readonly programChange: 192;
-    readonly channelPressure: 208;
-    readonly pitchWheel: 224;
-    readonly systemExclusive: 240;
-    readonly timecode: 241;
-    readonly songPosition: 242;
-    readonly songSelect: 243;
-    readonly tuneRequest: 246;
-    readonly clock: 248;
-    readonly start: 250;
-    readonly continue: 251;
-    readonly stop: 252;
-    readonly activeSensing: 254;
-    readonly reset: 255;
-    readonly sequenceNumber: 0;
-    readonly text: 1;
-    readonly copyright: 2;
-    readonly trackName: 3;
-    readonly instrumentName: 4;
-    readonly lyric: 5;
-    readonly marker: 6;
-    readonly cuePoint: 7;
-    readonly programName: 8;
-    readonly midiChannelPrefix: 32;
-    readonly midiPort: 33;
-    readonly endOfTrack: 47;
-    readonly setTempo: 81;
-    readonly smpteOffset: 84;
-    readonly timeSignature: 88;
-    readonly keySignature: 89;
-    readonly sequenceSpecific: 127;
-};
-type MIDIMessageType = (typeof midiMessageTypes)[keyof typeof midiMessageTypes];
-declare const midiControllers: {
-    readonly bankSelect: 0;
-    readonly modulationWheel: 1;
-    readonly breathController: 2;
-    readonly undefinedCC3: 3;
-    readonly footController: 4;
-    readonly portamentoTime: 5;
-    readonly dataEntryMSB: 6;
-    readonly mainVolume: 7;
-    readonly balance: 8;
-    readonly undefinedCC9: 9;
-    readonly pan: 10;
-    readonly expressionController: 11;
-    readonly effectControl1: 12;
-    readonly effectControl2: 13;
-    readonly undefinedCC14: 14;
-    readonly undefinedCC15: 15;
-    readonly generalPurposeController1: 16;
-    readonly generalPurposeController2: 17;
-    readonly generalPurposeController3: 18;
-    readonly generalPurposeController4: 19;
-    readonly undefinedCC20: 20;
-    readonly undefinedCC21: 21;
-    readonly undefinedCC22: 22;
-    readonly undefinedCC23: 23;
-    readonly undefinedCC24: 24;
-    readonly undefinedCC25: 25;
-    readonly undefinedCC26: 26;
-    readonly undefinedCC27: 27;
-    readonly undefinedCC28: 28;
-    readonly undefinedCC29: 29;
-    readonly undefinedCC30: 30;
-    readonly undefinedCC31: 31;
-    readonly bankSelectLSB: 32;
-    readonly modulationWheelLSB: 33;
-    readonly breathControllerLSB: 34;
-    readonly undefinedCC3LSB: 35;
-    readonly footControllerLSB: 36;
-    readonly portamentoTimeLSB: 37;
-    readonly dataEntryLSB: 38;
-    readonly mainVolumeLSB: 39;
-    readonly balanceLSB: 40;
-    readonly undefinedCC9LSB: 41;
-    readonly panLSB: 42;
-    readonly expressionControllerLSB: 43;
-    readonly effectControl1LSB: 44;
-    readonly effectControl2LSB: 45;
-    readonly undefinedCC14LSB: 46;
-    readonly undefinedCC15LSB: 47;
-    readonly undefinedCC16LSB: 48;
-    readonly undefinedCC17LSB: 49;
-    readonly undefinedCC18LSB: 50;
-    readonly undefinedCC19LSB: 51;
-    readonly undefinedCC20LSB: 52;
-    readonly undefinedCC21LSB: 53;
-    readonly undefinedCC22LSB: 54;
-    readonly undefinedCC23LSB: 55;
-    readonly undefinedCC24LSB: 56;
-    readonly undefinedCC25LSB: 57;
-    readonly undefinedCC26LSB: 58;
-    readonly undefinedCC27LSB: 59;
-    readonly undefinedCC28LSB: 60;
-    readonly undefinedCC29LSB: 61;
-    readonly undefinedCC30LSB: 62;
-    readonly undefinedCC31LSB: 63;
-    readonly sustainPedal: 64;
-    readonly portamentoOnOff: 65;
-    readonly sostenutoPedal: 66;
-    readonly softPedal: 67;
-    readonly legatoFootswitch: 68;
-    readonly hold2Pedal: 69;
-    readonly soundVariation: 70;
-    readonly filterResonance: 71;
-    readonly releaseTime: 72;
-    readonly attackTime: 73;
-    readonly brightness: 74;
-    readonly decayTime: 75;
-    readonly vibratoRate: 76;
-    readonly vibratoDepth: 77;
-    readonly vibratoDelay: 78;
-    readonly soundController10: 79;
-    readonly generalPurposeController5: 80;
-    readonly generalPurposeController6: 81;
-    readonly generalPurposeController7: 82;
-    readonly generalPurposeController8: 83;
-    readonly portamentoControl: 84;
-    readonly undefinedCC85: 85;
-    readonly undefinedCC86: 86;
-    readonly undefinedCC87: 87;
-    readonly undefinedCC88: 88;
-    readonly undefinedCC89: 89;
-    readonly undefinedCC90: 90;
-    readonly reverbDepth: 91;
-    readonly tremoloDepth: 92;
-    readonly chorusDepth: 93;
-    readonly variationDepth: 94;
-    readonly phaserDepth: 95;
-    readonly dataIncrement: 96;
-    readonly dataDecrement: 97;
-    readonly nonRegisteredParameterLSB: 98;
-    readonly nonRegisteredParameterMSB: 99;
-    readonly registeredParameterLSB: 100;
-    readonly registeredParameterMSB: 101;
-    readonly undefinedCC102LSB: 102;
-    readonly undefinedCC103LSB: 103;
-    readonly undefinedCC104LSB: 104;
-    readonly undefinedCC105LSB: 105;
-    readonly undefinedCC106LSB: 106;
-    readonly undefinedCC107LSB: 107;
-    readonly undefinedCC108LSB: 108;
-    readonly undefinedCC109LSB: 109;
-    readonly undefinedCC110LSB: 110;
-    readonly undefinedCC111LSB: 111;
-    readonly undefinedCC112LSB: 112;
-    readonly undefinedCC113LSB: 113;
-    readonly undefinedCC114LSB: 114;
-    readonly undefinedCC115LSB: 115;
-    readonly undefinedCC116LSB: 116;
-    readonly undefinedCC117LSB: 117;
-    readonly undefinedCC118LSB: 118;
-    readonly undefinedCC119LSB: 119;
-    readonly allSoundOff: 120;
-    readonly resetAllControllers: 121;
-    readonly localControlOnOff: 122;
-    readonly allNotesOff: 123;
-    readonly omniModeOff: 124;
-    readonly omniModeOn: 125;
-    readonly monoModeOn: 126;
-    readonly polyModeOn: 127;
-};
-type MIDIController = (typeof midiControllers)[keyof typeof midiControllers];
-
-interface EffectProcessor {
+    addToGenerator(type: GeneratorType, value: number, validate?: boolean): void;
     /**
-     * 0-127
-     * This parameter sets the amount of the effect sent to the effect output.
+     * Sets a generator to a given value if preset, otherwise adds a new one.
+     * @param type the generator type.
+     * @param value the value to set. Set to null to remove this generator (set as "unset").
+     * @param validate if the value should be clamped to allowed limits.
      */
-    level: number;
+    setGenerator(type: GeneratorType, value: number | null, validate?: boolean): void;
     /**
-     * 0-7
-     * A low-pass filter can be applied to the sound coming into the effect to cut the high
-     * frequency range. Higher values will cut more of the high frequencies, resulting in a
-     * more mellow effect sound.
+     * Adds generators to the zone.
+     * @param generators the generators to add.
      */
-    preLowpass: number;
-}
-interface ReverbProcessorSnapshot extends EffectProcessor {
+    addGenerators(...generators: Generator[]): void;
     /**
-     * 0-7.
-     * If character is not available, it should default to the first one.
-     *
-     * This parameter selects the type of reverb. 0–5 are reverb effects, and 6 and 7 are delay
-     * effects.
+     * Adds modulators to the zone.
+     * @param modulators the modulators to add.
      */
-    character: number;
+    addModulators(...modulators: Modulator[]): void;
     /**
-     * 0-127
-     * This parameter sets the time over which the reverberation will continue.
-     * Higher values result in longer reverberation.
+     * Gets a generator value.
+     * @param generatorType the generator type.
+     * @param notFoundValue if the generator is not found, this value is returned. A default value can be passed here, or null for example,
+     * to check if the generator is set.
      */
-    time: number;
+    getGenerator<K>(generatorType: GeneratorType, notFoundValue: number | K): number | K;
+    copyFrom(zone: BasicZone): void;
     /**
-     * 0-127
-     * This parameter is used when the Reverb Character is set to 6 or 7, or the Reverb Type
-     * is set to Delay or Panning Delay (Rev Character 6, 7). It sets the way in which delays
-     * repeat. Higher values result in more delay repeats.
+     * Filters the generators and prepends the range generators.
      */
-    delayFeedback: number;
+    getWriteGenerators(bank: BasicSoundBank): Generator[];
+}
+
+declare class BasicGlobalZone extends BasicZone {
+}
+
+declare class BasicInstrumentZone extends BasicZone {
     /**
-     * 0 - 127 (ms)
-     * This parameter sets the delay time until the reverberant sound is heard.
-     * Higher values result in a longer pre-delay time, simulating a larger reverberant space.
+     * The instrument this zone belongs to.
      */
-    preDelayTime: number;
-}
-interface ReverbProcessor extends ReverbProcessorSnapshot {
+    readonly parentInstrument: BasicInstrument;
     /**
-     * Process the effect and ADDS it to the output.
-     * @param input The input buffer to process. It always starts at index 0.
-     * @param outputLeft The left output buffer.
-     * @param outputRight The right output buffer.
-     * @param startIndex The index to start mixing at into the output buffers.
-     * @param sampleCount The amount of samples to mix.
+     * For tracking on the individual zone level, since multiple presets can refer to the same instrument.
      */
-    process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, startIndex: number, sampleCount: number): void;
+    useCount: number;
     /**
-     * Gets a synthesizer from this effect processor instance.
+     * Creates a new instrument zone.
+     * @param instrument The parent instrument.
+     * @param sample The sample to use in this zone.
      */
-    getSnapshot(): ReverbProcessorSnapshot;
-}
-interface ChorusProcessorSnapshot extends EffectProcessor {
+    constructor(instrument: BasicInstrument, sample: BasicSample);
     /**
-     * 0-127
-     * This parameter sets the level at which the chorus sound is re-input (fed back) into the
-     * chorus. By using feedback, a denser chorus sound can be created.
-     * Higher values result in a greater feedback level.
+     * Zone's sample.
      */
-    feedback: number;
+    private _sample;
     /**
-     * 0-127
-     * This parameter sets the delay time of the chorus effect.
+     * Zone's sample.
      */
-    delay: number;
+    get sample(): BasicSample;
     /**
-     * 0-127
-     * This parameter sets the speed (frequency) at which the chorus sound is modulated.
-     * Higher values result in faster modulation.
+     * Sets a sample for this zone.
+     * @param sample the sample to set.
      */
-    rate: number;
+    set sample(sample: BasicSample);
+    getWriteGenerators(bank: BasicSoundBank): Generator[];
+}
+
+declare class BasicPresetZone extends BasicZone {
     /**
-     * 0-127
-     * This parameter sets the depth at which the chorus sound is modulated.
-     * Higher values result in deeper modulation.
+     * The preset this zone belongs to.
      */
-    depth: number;
+    readonly parentPreset: BasicPreset;
     /**
-     * 0-127
-     * This parameter sets the amount of chorus sound that will be sent to the reverb.
-     * Higher values result in more sound being sent.
+     * Creates a new preset zone.
+     * @param preset the preset this zone belongs to.
+     * @param instrument the instrument to use in this zone.
      */
-    sendLevelToReverb: number;
+    constructor(preset: BasicPreset, instrument: BasicInstrument);
     /**
-     * 0-127
-     * This parameter sets the amount of chorus sound that will be sent to the delay.
-     * Higher values result in more sound being sent.
+     * Zone's instrument.
      */
-    sendLevelToDelay: number;
-}
-interface ChorusProcessor extends ChorusProcessorSnapshot {
+    private _instrument;
     /**
-     * Process the effect and ADDS it to the output.
-     * @param input The input buffer to process. It always starts at index 0.
-     * @param outputLeft The left output buffer.
-     * @param outputRight The right output buffer.
-     * @param outputReverb The mono input for reverb. It always starts at index 0.
-     * @param outputDelay The mono input for delay. It always starts at index 0.
-     * @param startIndex The index to start mixing at into the output buffers.
-     * @param sampleCount The amount of samples to mix.
+     * Zone's instrument.
      */
-    process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, outputDelay: Float32Array, startIndex: number, sampleCount: number): void;
+    get instrument(): BasicInstrument;
     /**
-     * Gets a synthesizer from this effect processor instance.
+     * Zone's instrument.
      */
-    getSnapshot(): ChorusProcessorSnapshot;
+    set instrument(instrument: BasicInstrument);
+    getWriteGenerators(bank: BasicSoundBank): Generator[];
 }
-interface DelayProcessorSnapshot extends EffectProcessor {
+
+/**
+ * Returned structure containing extended SF2 chunks.
+ */
+interface ExtendedSF2Chunks {
     /**
-     * 0-115
-     * 0.1ms-340ms-1000ms
-     * The delay effect has three delay times; center, left and
-     * right (when listening in stereo). Delay Time Center sets the delay time of the delay
-     * located at the center.
-     * Refer to SC-8850 Owner's Manual p. 236 for the exact mapping of the values.
+     * The PDTA part of the chunk.
      */
-    timeCenter: number;
+    pdta: IndexedByteArray;
     /**
-     * 0-120
-     * 4% - 500%
-     * This parameter sets the delay time of the delay located at the left as a percentage of
-     * the Delay Time Center (up to a max. of 1.0 s).
-     * The resolution is 100/24(%).
+     * The XDTA (https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md) part of the chunk.
+     */
+    xdta: IndexedByteArray;
+}
+/**
+ * Write indexes for tracking writing a SoundFont file.
+ */
+interface SoundFontWriteIndexes {
+    /**
+     * Generator start index.
+     */
+    gen: number;
+    /**
+     * Modulator start index.
      */
-    timeRatioLeft: number;
+    mod: number;
     /**
-     * 1-120
-     * 4%-500%
-     * This parameter sets the delay time of the delay located at the right as a percentage of
-     * the Delay Time Center (up to a max. of 1.0 s).
-     * The resolution is 100/24(%).
+     * Zone start index.
      */
-    timeRatioRight: number;
+    bag: number;
     /**
-     * 0-127
-     * This parameter sets the volume of the central delay. Higher values result in a louder
-     * center delay.
+     * Preset/instrument start index.
      */
-    levelCenter: number;
+    hdr: number;
+}
+
+declare class BasicPreset implements MIDIPatchNamed {
     /**
-     * 0-127
-     * This parameter sets the volume of the left delay. Higher values result in a louder left
-     * delay.
+     * The parent soundbank instance
+     * Currently used for determining default modulators and XG status
      */
-    levelLeft: number;
+    readonly parentSoundBank: BasicSoundBank;
     /**
-     * 0-127
-     * This parameter sets the volume of the right delay. Higher values result in a louder
-     * right delay.
+     * The preset's name
      */
-    levelRight: number;
+    name: string;
+    program: number;
+    bankMSB: number;
+    bankLSB: number;
+    isGMGSDrum: boolean;
     /**
-     * 0-127
-     * (-64)-63
-     * This parameter affects the number of times the delay will repeat. With a value of 0,
-     * the delay will not repeat. With higher values there will be more repeats.
-     * With negative (-) values, the center delay will be fed back with inverted phase.
-     * Negative values are effective with short delay times.
+     * The preset's zones
      */
-    feedback: number;
+    zones: BasicPresetZone[];
     /**
-     * 0-127
-     * This parameter sets the amount of delay sound that is sent to the reverb.
-     * Higher values result in more sound being sent.
+     * Preset's global zone
      */
-    sendLevelToReverb: number;
-}
-interface DelayProcessor extends DelayProcessorSnapshot {
+    readonly globalZone: BasicGlobalZone;
     /**
-     * Process the effect and ADDS it to the output.
-     * @param input The input buffer to process. It always starts at index 0.
-     * @param outputLeft The left output buffer.
-     * @param outputRight The right output buffer.
-     * @param outputReverb The mono input for reverb. It always starts at index 0.
-     * @param startIndex The index to start mixing at into the output buffers.
-     * @param sampleCount The amount of samples to mix.
+     * Unused metadata
      */
-    process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, startIndex: number, sampleCount: number): void;
+    library: number;
     /**
-     * Gets a synthesizer from this effect processor instance.
+     * Unused metadata
      */
-    getSnapshot(): DelayProcessorSnapshot;
-}
-interface InsertionProcessor {
+    genre: number;
     /**
-     * The EFX type of this processor, stored as MSB << | LSB.
-     * For example 0x30, 0x10 is 0x3010
+     * Unused metadata
      */
-    readonly type: number;
+    morphology: number;
     /**
-     * 0-1 (floating point)
-     * This parameter sets the amount of insertion sound that will be sent to the reverb.
-     * Higher values result in more sound being sent.
+     * Creates a new preset representation.
+     * @param parentSoundBank the sound bank this preset belongs to.
+     * @param globalZone optional, a global zone to use.
      */
-    sendLevelToReverb: number;
+    constructor(parentSoundBank: BasicSoundBank, globalZone?: BasicGlobalZone);
+    get isXGDrums(): boolean;
     /**
-     * 0-1 (floating point)
-     * This parameter sets the amount of insertion sound that will be sent to the chorus.
-     * Higher values result in more sound being sent.
+     * Checks if this preset is a drum preset
      */
-    sendLevelToChorus: number;
+    get isAnyDrums(): boolean;
+    private static isInRange;
+    private static addUniqueModulators;
+    private static subtractRanges;
     /**
-     * 0-1 (floating point)
-     * This parameter sets the amount of insertion sound that will be sent to the delay.
-     * Higher values result in more sound being sent.
+     * Unlinks everything from this preset.
      */
-    sendLevelToDelay: number;
+    delete(): void;
     /**
-     * Resets the params to their default values.
-     * This does not need to reset send levels.
+     * Deletes an instrument zone from this preset.
+     * @param index the zone's index to delete.
      */
-    reset(): void;
+    deleteZone(index: number): void;
     /**
-     * Sets an EFX parameter.
-     * @param parameter The parameter number (0x03-0x16).
-     * @param value The new value (0-127).
+     * Creates a new preset zone and returns it.
+     * @param instrument the instrument to use in the zone.
      */
-    setParameter(parameter: number, value: number): void;
+    createZone(instrument: BasicInstrument): BasicPresetZone;
     /**
-     * Process the effect and ADDS it to the output.
-     * @param inputLeft The left input buffer to process. It always starts at index 0.
-     * @param inputRight The right input buffer to process. It always starts at index 0.
-     * @param outputLeft The left output buffer.
-     * @param outputRight The right output buffer.
-     * @param outputReverb The mono input for reverb. It always starts at index 0.
-     * @param outputChorus The mono input for chorus. It always starts at index 0.
-     * @param outputDelay The mono input for delay. It always starts at index 0.
-     * @param startIndex The index to start mixing at into the output buffers.
-     * @param sampleCount The amount of samples to mix.
+     * Preloads (loads and caches synthesis data) for a given key range.
      */
-    process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, outputChorus: Float32Array, outputDelay: Float32Array, startIndex: number, sampleCount: number): void;
-}
-interface InsertionProcessorSnapshot {
-    type: number;
+    preload(keyMin: number, keyMax: number): void;
     /**
-     * 20 parameters for the effect, 255 means "no change" + 3 effect sends (index 20, 21, 22)
+     * Checks if the bank and program numbers are the same for the given preset as this one.
+     * @param preset The preset to check.
      */
-    params: Uint8Array;
+    matches(preset: MIDIPatch): boolean;
     /**
-     * A boolean list for channels that have the insertion effect enabled.
+     * Returns the voice synthesis data for this preset.
+     * @param midiNote the MIDI note number.
+     * @param velocity the MIDI velocity.
+     * @returns the returned sound data.
      */
-    channels: boolean[];
-}
-type InsertionProcessorConstructor = new (sampleRate: number, maxBufferSize: number) => InsertionProcessor;
-
-type SynthSystem = "gm" | "gm2" | "gs" | "xg";
-interface NoteOnCallback {
-    /** The MIDI note number. */
-    midiNote: number;
-    /** The MIDI channel number. */
-    channel: number;
-    /** The velocity of the note. */
-    velocity: number;
-}
-interface NoteOffCallback {
-    /** The MIDI note number. */
-    midiNote: number;
-    /** The MIDI channel number. */
-    channel: number;
-}
-interface DrumChangeCallback {
-    /** The MIDI channel number. */
-    channel: number;
-    /** Indicates if the channel is a drum channel. */
-    isDrumChannel: boolean;
-}
-interface ProgramChangeCallback extends MIDIPatch {
-    /** The MIDI channel number. */
-    channel: number;
-}
-interface ControllerChangeCallback {
-    /** The MIDI channel number. */
-    channel: number;
-    /** The controller number. */
-    controllerNumber: MIDIController;
-    /** The value of the controller. */
-    controllerValue: number;
-}
-interface MuteChannelCallback {
-    /** The MIDI channel number. */
-    channel: number;
-    /** Indicates if the channel is muted. */
-    isMuted: boolean;
-}
-interface PresetListEntry extends MIDIPatchNamed {
+    getVoiceParameters(midiNote: number, velocity: number): VoiceParameters[];
     /**
-     * Indicates if this preset is any kind of drum preset.
+     * BankMSB:bankLSB:program:isGMGSDrum
      */
-    isAnyDrums: boolean;
-}
-/**
- * A list of preset changes, each with a name, bank, and program number.
- */
-type PresetList = PresetListEntry[];
-/**
- * The synthesizer display system exclusive data, EXCLUDING THE F0 BYTE!
- */
-type SynthDisplayCallback = number[];
-interface PitchWheelCallback {
-    /** The MIDI channel number. */
-    channel: number;
+    toMIDIString(): string;
+    toString(): string;
     /**
-     * The unsigned 14-bit value of the pitch: 0 - 16383.
+     * Combines preset into an instrument, flattening the preset zones into instrument zones.
+     * This is a really complex function that attempts to work around the DLS limitations of only having the instrument layer.
+     * @returns The instrument containing the flattened zones. In theory, it should exactly the same as this preset.
      */
-    pitch: number;
+    toFlattenedInstrument(): BasicInstrument;
     /**
-     * If the pitch wheel was note-specific, this is the MIDI note number that was altered. Set to -1 otherwise.
+     * Writes the SF2 header
+     * @param phdrData
+     * @param index
      */
-    midiNote: number;
-}
-interface ChannelPressureCallback {
-    /** The MIDI channel number. */
-    channel: number;
-    /** The pressure value. */
-    pressure: number;
-}
-interface PolyPressureCallback {
-    /** The MIDI channel number. */
-    channel: number;
-    /** The MIDI note number. */
-    midiNote: number;
-    /** The pressure value. */
-    pressure: number;
+    write(phdrData: ExtendedSF2Chunks, index: number): void;
 }
+
 /**
- * The error message for sound bank errors.
+ * Represents a single instrument
  */
-type SoundBankErrorCallback = Error;
-interface StopAllCallback {
-    /**
-     * The MIDI channel number.
-     */
-    channel: number;
+declare class BasicInstrument {
     /**
-     * If the channel was force stopped. (no release time)
+     * The instrument's name
      */
-    force: boolean;
-}
-type MasterParameterChangeCallback = {
-    [P in keyof MasterParameterType]: {
-        /**
-         * The parameter that was changed.
-         */
-        parameter: P;
-        /**
-         * The new value of this parameter.
-         */
-        value: MasterParameterType[P];
-    };
-}[keyof MasterParameterType];
-interface ChannelPropertyChangeCallback {
+    name: string;
     /**
-     * The channel number of the new property.
+     * The instrument's zones
      */
-    channel: number;
+    zones: BasicInstrumentZone[];
     /**
-     * The updated property.
+     * Instrument's global zone
      */
-    property: ChannelProperty;
-}
-type FXType<K> = Exclude<keyof K, "process" | "getSnapshot"> | "macro";
-type EffectChangeCallback = {
+    readonly globalZone: BasicGlobalZone;
     /**
-     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
+     * Instrument's linked presets (the presets that use it)
+     * note that duplicates are allowed since one preset can use the same instrument multiple times.
      */
-    effect: "reverb";
+    readonly linkedTo: BasicPreset[];
     /**
-     * The parameter type or "macro".
+     * How many presets is this instrument used by
      */
-    parameter: FXType<ReverbProcessor>;
+    get useCount(): number;
     /**
-     * The new 7-bit value.
+     * Creates a new instrument zone and returns it.
+     * @param sample The sample to use in the zone.
      */
-    value: number;
-} | {
+    createZone(sample: BasicSample): BasicInstrumentZone;
     /**
-     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
+     * Links the instrument ta a given preset
+     * @param preset the preset to link to
      */
-    effect: "chorus";
+    linkTo(preset: BasicPreset): void;
     /**
-     * The parameter type or "macro".
+     * Unlinks the instrument from a given preset
+     * @param preset the preset to unlink from
      */
-    parameter: FXType<ChorusProcessor>;
+    unlinkFrom(preset: BasicPreset): void;
+    deleteUnusedZones(): void;
+    delete(): void;
     /**
-     * The new 7-bit value.
+     * Deletes a given instrument zone if it has no uses
+     * @param index the index of the zone to delete
+     * @param force ignores the use count and deletes forcibly
+     * @returns if the zone has been deleted
      */
-    value: number;
-} | {
+    deleteZone(index: number, force?: boolean): boolean;
     /**
-     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
+     * Globalizes the instrument *in-place.*
+     * This means trying to move as many generators and modulators
+     * to the global zone as possible to reduce clutter and the count of parameters.
      */
-    effect: "delay";
+    globalize(): void;
+    write(instData: ExtendedSF2Chunks, index: number): void;
+}
+
+declare class BasicSample {
     /**
-     * The parameter type or "macro".
+     * The sample's name.
      */
-    parameter: FXType<DelayProcessor>;
+    name: string;
     /**
-     * The new 7-bit value.
+     * Sample rate in Hz.
      */
-    value: number;
-} | {
+    sampleRate: number;
     /**
-     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
+     * Original pitch of the sample as a MIDI note number.
      */
-    effect: "insertion";
+    originalKey: number;
     /**
-     * The parameter that was changed. This maps to GS address map at addr2 = 0x03.
-     * See SC-8850 Manual p.237,
-     * for example:
-     * - 0x0 - EFX type, the value is 16 bit in this special case. Note that this resets the parameters!
-     * - 0x3 - EFX param 1
-     * - 0x16 - EFX param 20 (usually level)
-     * - 0x17 - EFX send to reverb
-     *
-     * There are two exceptions:
-     * - -1 - the channel has ENABLED the effect.
-     * - -2 - the channel has DISABLED the effect.
-     * For both of these cases, `value` is the channel number.
+     * Pitch correction, in cents. Can be negative.
      */
-    parameter: number;
+    pitchCorrection: number;
     /**
-     * The new value for the parameter.
+     * Linked sample, unused if mono.
      */
-    value: number;
-};
-interface SynthProcessorEventData {
+    linkedSample?: BasicSample;
     /**
-     * This event fires when a note is played.
+     * The type of the sample.
      */
-    noteOn: NoteOnCallback;
+    sampleType: SampleType;
     /**
-     * This event fires when a note is released.
+     * Relative to the start of the sample in sample points.
      */
-    noteOff: NoteOffCallback;
+    loopStart: number;
     /**
-     * This event fires when a pitch wheel is changed.
+     * Relative to the start of the sample in sample points.
      */
-    pitchWheel: PitchWheelCallback;
+    loopEnd: number;
     /**
-     * This event fires when a controller is changed.
+     * Sample's linked instruments (the instruments that use it)
+     * note that duplicates are allowed since one instrument can use the same sample multiple times.
      */
-    controllerChange: ControllerChangeCallback;
+    linkedTo: BasicInstrument[];
     /**
-     * This event fires when a program is changed.
+     * Indicates if the data was overridden, so it cannot be copied back unchanged.
      */
-    programChange: ProgramChangeCallback;
+    protected dataOverridden: boolean;
     /**
-     * This event fires when a channel pressure is changed.
+     * The compressed sample data if the sample has been compressed.
      */
-    channelPressure: ChannelPressureCallback;
+    protected compressedData?: Uint8Array;
     /**
-     * This event fires when a polyphonic pressure is changed.
+     * The sample's audio data.
      */
-    polyPressure: PolyPressureCallback;
+    protected audioData?: Float32Array;
     /**
-     * This event fires when a drum channel is changed.
+     * The basic representation of a sample
+     * @param sampleName The sample's name
+     * @param sampleRate The sample's rate in Hz
+     * @param originalKey The sample's pitch as a MIDI note number
+     * @param pitchCorrection The sample's pitch correction in cents
+     * @param sampleType The sample's type, an enum that can indicate SF3
+     * @param loopStart The sample's loop start relative to the sample start in sample points
+     * @param loopEnd The sample's loop end relative to the sample start in sample points
      */
-    drumChange: DrumChangeCallback;
+    constructor(sampleName: string, sampleRate: number, originalKey: number, pitchCorrection: number, sampleType: SampleType, loopStart: number, loopEnd: number);
     /**
-     * This event fires when all notes on a channel are stopped.
+     * Indicates if the sample is compressed using vorbis SF3.
      */
-    stopAll: StopAllCallback;
+    get isCompressed(): boolean;
     /**
-     * This event fires when a new channel is created. There is no data for this event.
+     * If the sample is linked to another sample.
      */
-    newChannel: void;
+    get isLinked(): boolean;
     /**
-     * This event fires when a channel is muted or unmuted.
+     * The sample's use count
      */
-    muteChannel: MuteChannelCallback;
+    get useCount(): number;
     /**
-     * This event fires when the preset list is changed.
+     * Get raw data for writing the file, either a compressed bit stream or signed 16-bit little endian PCM data.
+     * @param allowVorbis if vorbis file data is allowed.
+     * @return either s16le or vorbis data.
      */
-    presetListChange: PresetList;
+    getRawData(allowVorbis: boolean): Uint8Array;
     /**
-     * This event fires when all controllers on all channels are reset. There is no data for this event.
+     * Resamples the audio data to a given sample rate.
      */
-    allControllerReset: void;
+    resampleData(newSampleRate: number): void;
     /**
-     * This event fires when a sound bank parsing error occurs.
+     * Compresses the audio data
+     * @param encodeVorbis the compression function to use when compressing
      */
-    soundBankError: SoundBankErrorCallback;
+    compressSample(encodeVorbis: SampleEncodingFunction): Promise<void>;
     /**
-     * This event fires when the synthesizer receives a display message.
+     * Sets the sample type and unlinks if needed.
+     * @param type The type to set it to.
      */
-    synthDisplay: SynthDisplayCallback;
+    setSampleType(type: SampleType): void;
     /**
-     * This event fires when a master parameter changes.
+     * Unlinks the sample from its stereo link if it has any.
      */
-    masterParameterChange: MasterParameterChangeCallback;
+    unlinkSample(): void;
     /**
-     * This event fires when a channel property changes.
+     * Links a stereo sample.
+     * @param sample the sample to link to.
+     * @param type either left, right or linked.
      */
-    channelPropertyChange: ChannelPropertyChangeCallback;
+    setLinkedSample(sample: BasicSample, type: SampleType): void;
     /**
-     * This event fires when an effect processor is modified.
+     * Links the sample to a given instrument
+     * @param instrument the instrument to link to
      */
-    effectChange: EffectChangeCallback;
-}
-type SynthProcessorEvent = {
-    [K in keyof SynthProcessorEventData]: {
-        type: K;
-        data: SynthProcessorEventData[K];
-    };
-}[keyof SynthProcessorEventData];
-interface SynthMethodOptions {
+    linkTo(instrument: BasicInstrument): void;
     /**
-     * The audio context time when the event should execute, in seconds.
+     * Unlinks the sample from a given instrument
+     * @param instrument the instrument to unlink from
      */
-    time: number;
-}
-/**
- * Looping mode of the sample.
- * 0 - no loop.
- * 1 - loop.
- * 2 - UNOFFICIAL: polyphone 2.4 added start on release.
- * 3 - loop then play when released.
- */
-type SampleLoopingMode = 0 | 1 | 2 | 3;
-/**
- * A list of voices for a given key:velocity.
- */
-type CachedVoiceList = CachedVoice[];
-interface ChannelProperty {
+    unlinkFrom(instrument: BasicInstrument): void;
     /**
-     * The channel's current voice amount.
+     * Get the float32 audio data.
+     * Note that this either decodes the compressed data or passes the ready sampleData.
+     * If neither are set then it will throw an error!
+     * @returns the audio data
      */
-    voicesAmount: number;
+    getAudioData(): Float32Array;
     /**
-     * The channel's current pitch wheel 0 - 16384.
+     * Replaces the audio data *in-place*.
+     * @param audioData The new audio data as Float32.
+     * @param sampleRate The new sample rate, in Hertz.
      */
-    pitchWheel: number;
+    setAudioData(audioData: Float32Array, sampleRate: number): void;
     /**
-     * The pitch wheel's range, in semitones.
+     * Replaces the audio with a compressed data sample and flags the sample as compressed
+     * @param data the new compressed data
      */
-    pitchWheelRange: number;
+    setCompressedData(data: Uint8Array): void;
     /**
-     * Indicates whether the channel is muted.
+     * Encodes s16le sample
+     * @return the encoded data
      */
-    isMuted: boolean;
+    protected encodeS16LE(): IndexedByteArray;
     /**
-     * Indicates whether the channel is a drum channel.
+     * Decode binary vorbis into a float32 pcm
      */
-    isDrum: boolean;
+    protected decodeVorbis(): Float32Array;
+}
+declare class EmptySample extends BasicSample {
     /**
-     * Indicates whether the channel uses an insertion effect.
-     * This means that there will be no separate dry output for processSplit().
+     * A simplified class for creating samples.
      */
-    isEFX: boolean;
+    constructor();
+}
+
+declare class SoundBankLoader {
     /**
-     * The channel's transposition, in semitones.
+     * Loads a sound bank from a file buffer.
+     * @param buffer The binary file buffer to load.
+     * @returns The loaded sound bank, a BasicSoundBank instance.
      */
-    transposition: number;
+    static fromArrayBuffer(buffer: ArrayBuffer): BasicSoundBank;
+    private static loadDLS;
 }
-interface SynthProcessorOptions {
+
+declare class VoiceModulator extends Modulator {
     /**
-     * The maximum buffer size the synthesizer can render at once.
-     * Attempting to `.process()` more samples than this will result in an error.
-     * Defaults to 128.
+     * Indicates if the given modulator is chorus or reverb effects modulator.
+     * This is done to simulate BASSMIDI effects behavior:
+     * - defaults to 1000 transform amount rather than 200
+     * - values can be changed, but anything above 200 is 1000
+     * (except for values above 1000, they are copied directly)
+     * - all values below are multiplied by 5 (200 * 5 = 1000)
+     * - still can be disabled if the soundfont has its own modulator curve
+     * - this fixes the very low amount of reverb by default and doesn't break soundfonts
      */
-    maxBufferSize: number;
+    readonly isEffectModulator: boolean;
     /**
-     * Indicates if the event system is enabled. This can be changed later.
+     * The default resonant modulator does not affect the filter gain.
+     * Neither XG nor GS responded to cc #74 in that way.
      */
-    enableEventSystem: boolean;
+    readonly isDefaultResonantModulator: boolean;
     /**
-     * The initial time of the synth, in seconds.
+     * If this is a modulation wheel modulator (for modulation depth range).
      */
-    initialTime: number;
+    readonly isModWheelModulator: boolean;
+    private constructor();
+    static fromData(s1: ModulatorSource, s2: ModulatorSource, destination: GeneratorType, amount: number, transformType: ModulatorTransformType): VoiceModulator;
+    static fromModulator(mod: Modulator): VoiceModulator;
+}
+
+/**
+ * Represents a cached voice
+ */
+declare class CachedVoice {
     /**
-     * Indicates if the effects are enabled. This can be changed later.
+     * Sample data of this voice.
      */
-    enableEffects: boolean;
+    readonly sampleData: Float32Array;
     /**
-     * Reverb processor for the synthesizer. Leave undefined to use the default.
+     * The unmodulated (copied to) generators of the voice.
      */
-    reverbProcessor?: ReverbProcessor;
+    readonly generators: Int16Array;
     /**
-     * Chorus processor for the synthesizer. Leave undefined to use the default.
+     * The voice's modulators.
      */
-    chorusProcessor?: ChorusProcessor;
+    readonly modulators: VoiceModulator[];
     /**
-     * Delay processor for the synthesizer. Leave undefined to use the default.
+     * Exclusive class number for hi-hats etc.
      */
-    delayProcessor?: DelayProcessor;
-}
-/**
- * The master parameters of the synthesizer.
- */
-interface MasterParameterType {
+    readonly exclusiveClass: number;
     /**
-     * The master gain, from 0 to any number. 1 is 100% volume.
+     * Target key of the voice (can be overridden by generators)
      */
-    masterGain: number;
+    readonly targetKey: number;
     /**
-     * The master pan, from -1 (left) to 1 (right). 0 is center.
+     * Target velocity of the voice (can be overridden by generators)
      */
-    masterPan: number;
+    readonly velocity: number;
     /**
-     * The maximum number of voices that can be played at once.
-     *
-     * @remarks
-     * Increasing this value causes memory allocation for more voices.
-     * It is recommended to set it at the beginning, before rendering audio to avoid GC.
-     * Decreasing it does not cause memory usage change, so it's fine to use.
+     * MIDI root key of the sample
      */
-    voiceCap: number;
+    readonly rootKey: number;
     /**
-     * Enabling this parameter will cause a new voice allocation when the voice cap is hit, rather than stealing existing voices.
-     *
-     * @remarks
-     * This is not recommended in real-time environments.
+     * Start position of the loop
      */
-    autoAllocateVoices: boolean;
+    readonly loopStart: number;
     /**
-     * The interpolation type used for sample playback.
+     * End position of the loop
      */
-    interpolationType: InterpolationType;
+    readonly loopEnd: number;
     /**
-     * The MIDI system used by the synthesizer for bank selects and system exclusives. (GM, GM2, GS, XG)
+     * Playback step (rate) for sample pitch correction
      */
-    midiSystem: SynthSystem;
+    readonly playbackStep: number;
+    readonly loopingMode: SampleLoopingMode;
+    constructor(voiceParams: VoiceParameters, midiNote: number, velocity: number, sampleRate: number);
+}
+
+declare const midiMessageTypes: {
+    readonly noteOff: 128;
+    readonly noteOn: 144;
+    readonly polyPressure: 160;
+    readonly controllerChange: 176;
+    readonly programChange: 192;
+    readonly channelPressure: 208;
+    readonly pitchWheel: 224;
+    readonly systemExclusive: 240;
+    readonly timecode: 241;
+    readonly songPosition: 242;
+    readonly songSelect: 243;
+    readonly tuneRequest: 246;
+    readonly clock: 248;
+    readonly start: 250;
+    readonly continue: 251;
+    readonly stop: 252;
+    readonly activeSensing: 254;
+    readonly reset: 255;
+    readonly sequenceNumber: 0;
+    readonly text: 1;
+    readonly copyright: 2;
+    readonly trackName: 3;
+    readonly instrumentName: 4;
+    readonly lyric: 5;
+    readonly marker: 6;
+    readonly cuePoint: 7;
+    readonly programName: 8;
+    readonly midiChannelPrefix: 32;
+    readonly midiPort: 33;
+    readonly endOfTrack: 47;
+    readonly setTempo: 81;
+    readonly smpteOffset: 84;
+    readonly timeSignature: 88;
+    readonly keySignature: 89;
+    readonly sequenceSpecific: 127;
+};
+type MIDIMessageType = (typeof midiMessageTypes)[keyof typeof midiMessageTypes];
+declare const midiControllers: {
+    readonly bankSelect: 0;
+    readonly modulationWheel: 1;
+    readonly breathController: 2;
+    readonly undefinedCC3: 3;
+    readonly footController: 4;
+    readonly portamentoTime: 5;
+    readonly dataEntryMSB: 6;
+    readonly mainVolume: 7;
+    readonly balance: 8;
+    readonly undefinedCC9: 9;
+    readonly pan: 10;
+    readonly expressionController: 11;
+    readonly effectControl1: 12;
+    readonly effectControl2: 13;
+    readonly undefinedCC14: 14;
+    readonly undefinedCC15: 15;
+    readonly generalPurposeController1: 16;
+    readonly generalPurposeController2: 17;
+    readonly generalPurposeController3: 18;
+    readonly generalPurposeController4: 19;
+    readonly undefinedCC20: 20;
+    readonly undefinedCC21: 21;
+    readonly undefinedCC22: 22;
+    readonly undefinedCC23: 23;
+    readonly undefinedCC24: 24;
+    readonly undefinedCC25: 25;
+    readonly undefinedCC26: 26;
+    readonly undefinedCC27: 27;
+    readonly undefinedCC28: 28;
+    readonly undefinedCC29: 29;
+    readonly undefinedCC30: 30;
+    readonly undefinedCC31: 31;
+    readonly bankSelectLSB: 32;
+    readonly modulationWheelLSB: 33;
+    readonly breathControllerLSB: 34;
+    readonly undefinedCC3LSB: 35;
+    readonly footControllerLSB: 36;
+    readonly portamentoTimeLSB: 37;
+    readonly dataEntryLSB: 38;
+    readonly mainVolumeLSB: 39;
+    readonly balanceLSB: 40;
+    readonly undefinedCC9LSB: 41;
+    readonly panLSB: 42;
+    readonly expressionControllerLSB: 43;
+    readonly effectControl1LSB: 44;
+    readonly effectControl2LSB: 45;
+    readonly undefinedCC14LSB: 46;
+    readonly undefinedCC15LSB: 47;
+    readonly undefinedCC16LSB: 48;
+    readonly undefinedCC17LSB: 49;
+    readonly undefinedCC18LSB: 50;
+    readonly undefinedCC19LSB: 51;
+    readonly undefinedCC20LSB: 52;
+    readonly undefinedCC21LSB: 53;
+    readonly undefinedCC22LSB: 54;
+    readonly undefinedCC23LSB: 55;
+    readonly undefinedCC24LSB: 56;
+    readonly undefinedCC25LSB: 57;
+    readonly undefinedCC26LSB: 58;
+    readonly undefinedCC27LSB: 59;
+    readonly undefinedCC28LSB: 60;
+    readonly undefinedCC29LSB: 61;
+    readonly undefinedCC30LSB: 62;
+    readonly undefinedCC31LSB: 63;
+    readonly sustainPedal: 64;
+    readonly portamentoOnOff: 65;
+    readonly sostenutoPedal: 66;
+    readonly softPedal: 67;
+    readonly legatoFootswitch: 68;
+    readonly hold2Pedal: 69;
+    readonly soundVariation: 70;
+    readonly filterResonance: 71;
+    readonly releaseTime: 72;
+    readonly attackTime: 73;
+    readonly brightness: 74;
+    readonly decayTime: 75;
+    readonly vibratoRate: 76;
+    readonly vibratoDepth: 77;
+    readonly vibratoDelay: 78;
+    readonly soundController10: 79;
+    readonly generalPurposeController5: 80;
+    readonly generalPurposeController6: 81;
+    readonly generalPurposeController7: 82;
+    readonly generalPurposeController8: 83;
+    readonly portamentoControl: 84;
+    readonly undefinedCC85: 85;
+    readonly undefinedCC86: 86;
+    readonly undefinedCC87: 87;
+    readonly undefinedCC88: 88;
+    readonly undefinedCC89: 89;
+    readonly undefinedCC90: 90;
+    readonly reverbDepth: 91;
+    readonly tremoloDepth: 92;
+    readonly chorusDepth: 93;
+    readonly variationDepth: 94;
+    readonly phaserDepth: 95;
+    readonly dataIncrement: 96;
+    readonly dataDecrement: 97;
+    readonly nonRegisteredParameterLSB: 98;
+    readonly nonRegisteredParameterMSB: 99;
+    readonly registeredParameterLSB: 100;
+    readonly registeredParameterMSB: 101;
+    readonly undefinedCC102LSB: 102;
+    readonly undefinedCC103LSB: 103;
+    readonly undefinedCC104LSB: 104;
+    readonly undefinedCC105LSB: 105;
+    readonly undefinedCC106LSB: 106;
+    readonly undefinedCC107LSB: 107;
+    readonly undefinedCC108LSB: 108;
+    readonly undefinedCC109LSB: 109;
+    readonly undefinedCC110LSB: 110;
+    readonly undefinedCC111LSB: 111;
+    readonly undefinedCC112LSB: 112;
+    readonly undefinedCC113LSB: 113;
+    readonly undefinedCC114LSB: 114;
+    readonly undefinedCC115LSB: 115;
+    readonly undefinedCC116LSB: 116;
+    readonly undefinedCC117LSB: 117;
+    readonly undefinedCC118LSB: 118;
+    readonly undefinedCC119LSB: 119;
+    readonly allSoundOff: 120;
+    readonly resetAllControllers: 121;
+    readonly localControlOnOff: 122;
+    readonly allNotesOff: 123;
+    readonly omniModeOff: 124;
+    readonly omniModeOn: 125;
+    readonly monoModeOn: 126;
+    readonly polyModeOn: 127;
+};
+type MIDIController = (typeof midiControllers)[keyof typeof midiControllers];
+
+interface EffectProcessor {
     /**
-     * Indicates whether the synthesizer is in monophonic retrigger mode.
-     * This emulates the behavior of Microsoft GS Wavetable Synth,
-     * Where a new note will kill the previous one if it is still playing.
+     * 0-127
+     * This parameter sets the amount of the effect sent to the effect output.
      */
-    monophonicRetriggerMode: boolean;
+    level: number;
     /**
-     * The reverb gain, from 0 to any number. 1 is 100% reverb.
+     * 0-7
+     * A low-pass filter can be applied to the sound coming into the effect to cut the high
+     * frequency range. Higher values will cut more of the high frequencies, resulting in a
+     * more mellow effect sound.
      */
-    reverbGain: number;
+    preLowpass: number;
+}
+interface ReverbProcessorSnapshot extends EffectProcessor {
     /**
-     * If the synthesizer should prevent editing of the reverb parameters.
-     * This effect is modified using MIDI system exclusive messages, so
-     * the recommended use case would be setting
-     * the reverb parameters then locking it to prevent changes by MIDI files.
+     * 0-7.
+     * If character is not available, it should default to the first one.
+     *
+     * This parameter selects the type of reverb. 0–5 are reverb effects, and 6 and 7 are delay
+     * effects.
      */
-    reverbLock: boolean;
+    character: number;
     /**
-     * The chorus gain, from 0 to any number. 1 is 100% chorus.
+     * 0-127
+     * This parameter sets the time over which the reverberation will continue.
+     * Higher values result in longer reverberation.
      */
-    chorusGain: number;
+    time: number;
     /**
-     * If the synthesizer should prevent editing of the chorus parameters.
-     * This effect is modified using MIDI system exclusive messages, so
-     * the recommended use case would be setting
-     * the chorus parameters then locking it to prevent changes by MIDI files.
+     * 0-127
+     * This parameter is used when the Reverb Character is set to 6 or 7, or the Reverb Type
+     * is set to Delay or Panning Delay (Rev Character 6, 7). It sets the way in which delays
+     * repeat. Higher values result in more delay repeats.
      */
-    chorusLock: boolean;
+    delayFeedback: number;
     /**
-     * The delay gain, from 0 to any number. 1 is 100% delay.
+     * 0 - 127 (ms)
+     * This parameter sets the delay time until the reverberant sound is heard.
+     * Higher values result in a longer pre-delay time, simulating a larger reverberant space.
      */
-    delayGain: number;
+    preDelayTime: number;
+}
+interface ReverbProcessor extends ReverbProcessorSnapshot {
     /**
-     * If the synthesizer should prevent editing of the delay parameters.
-     * This effect is modified using MIDI system exclusive messages, so
-     * the recommended use case would be setting
-     * the delay parameters then locking it to prevent changes by MIDI files.
+     * Process the effect and ADDS it to the output.
+     * @param input The input buffer to process. It always starts at index 0.
+     * @param outputLeft The left output buffer.
+     * @param outputRight The right output buffer.
+     * @param startIndex The index to start mixing at into the output buffers.
+     * @param sampleCount The amount of samples to mix.
      */
-    delayLock: boolean;
+    process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, startIndex: number, sampleCount: number): void;
     /**
-     * If the synthesizer should prevent changing the insertion effect type and parameters (including enabling/disabling it on channels).
-     * This effect is modified using MIDI system exclusive messages, so
-     * the recommended use case would be setting
-     * the insertion effect type and parameters then locking it to prevent changes by MIDI files.
+     * Gets a synthesizer from this effect processor instance.
      */
-    insertionEffectLock: boolean;
+    getSnapshot(): ReverbProcessorSnapshot;
+}
+interface ChorusProcessorSnapshot extends EffectProcessor {
     /**
-     * If the synthesizer should prevent editing of the drum parameters.
-     * These params are modified using MIDI system exclusive messages or NRPN, so
-     * the recommended use case would be setting
-     * the drum parameters then locking it to prevent changes by MIDI files.
+     * 0-127
+     * This parameter sets the level at which the chorus sound is re-input (fed back) into the
+     * chorus. By using feedback, a denser chorus sound can be created.
+     * Higher values result in a greater feedback level.
      */
-    drumLock: boolean;
+    feedback: number;
     /**
-     * If the synthesizer should prevent applying the custom vibrato.
-     * This effect is modified using NRPN, so
-     * the recommended use case would be setting
-     * the custom vibrato then locking it to prevent changes by MIDI files.
+     * 0-127
+     * This parameter sets the delay time of the chorus effect.
      */
-    customVibratoLock: boolean;
+    delay: number;
     /**
-     * If the synthesizer should prevent changing any parameters via NRPN.
-     * This includes the custom vibrato parameters.
+     * 0-127
+     * This parameter sets the speed (frequency) at which the chorus sound is modulated.
+     * Higher values result in faster modulation.
      */
-    nprnParamLock: boolean;
+    rate: number;
     /**
-     * Forces note killing instead of releasing. Improves performance in black MIDIs.
+     * 0-127
+     * This parameter sets the depth at which the chorus sound is modulated.
+     * Higher values result in deeper modulation.
      */
-    blackMIDIMode: boolean;
+    depth: number;
     /**
-     * The global transposition in semitones. It can be decimal to provide microtonal tuning.
+     * 0-127
+     * This parameter sets the amount of chorus sound that will be sent to the reverb.
+     * Higher values result in more sound being sent.
      */
-    transposition: number;
+    sendLevelToReverb: number;
     /**
-     * Synthesizer's device ID for system exclusive messages. Set to -1 to accept all.
+     * 0-127
+     * This parameter sets the amount of chorus sound that will be sent to the delay.
+     * Higher values result in more sound being sent.
      */
-    deviceID: number;
+    sendLevelToDelay: number;
 }
-
-/**
- * Wavetable_oscillator.ts
- * purpose: plays back raw audio data at an arbitrary playback rate
- */
-declare abstract class WavetableOscillator {
+interface ChorusProcessor extends ChorusProcessorSnapshot {
     /**
-     * Is the loop on?
+     * Process the effect and ADDS it to the output.
+     * @param input The input buffer to process. It always starts at index 0.
+     * @param outputLeft The left output buffer.
+     * @param outputRight The right output buffer.
+     * @param outputReverb The mono input for reverb. It always starts at index 0.
+     * @param outputDelay The mono input for delay. It always starts at index 0.
+     * @param startIndex The index to start mixing at into the output buffers.
+     * @param sampleCount The amount of samples to mix.
      */
-    isLooping: boolean;
+    process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, outputDelay: Float32Array, startIndex: number, sampleCount: number): void;
     /**
-     * Sample data of the voice.
+     * Gets a synthesizer from this effect processor instance.
      */
-    sampleData?: Float32Array;
+    getSnapshot(): ChorusProcessorSnapshot;
+}
+interface DelayProcessorSnapshot extends EffectProcessor {
     /**
-     * Playback step (rate) for sample pitch correction.
+     * 0-115
+     * 0.1ms-340ms-1000ms
+     * The delay effect has three delay times; center, left and
+     * right (when listening in stereo). Delay Time Center sets the delay time of the delay
+     * located at the center.
+     * Refer to SC-8850 Owner's Manual p. 236 for the exact mapping of the values.
      */
-    playbackStep: number;
+    timeCenter: number;
     /**
-     * Start position of the loop.
+     * 0-120
+     * 4% - 500%
+     * This parameter sets the delay time of the delay located at the left as a percentage of
+     * the Delay Time Center (up to a max. of 1.0 s).
+     * The resolution is 100/24(%).
      */
-    loopStart: number;
+    timeRatioLeft: number;
     /**
-     * End position of the loop.
+     * 1-120
+     * 4%-500%
+     * This parameter sets the delay time of the delay located at the right as a percentage of
+     * the Delay Time Center (up to a max. of 1.0 s).
+     * The resolution is 100/24(%).
      */
-    loopEnd: number;
+    timeRatioRight: number;
     /**
-     * Length of the loop.
-     * @private
+     * 0-127
+     * This parameter sets the volume of the central delay. Higher values result in a louder
+     * center delay.
      */
-    loopLength: number;
+    levelCenter: number;
     /**
-     * End position of the sample.
+     * 0-127
+     * This parameter sets the volume of the left delay. Higher values result in a louder left
+     * delay.
      */
-    end: number;
+    levelLeft: number;
     /**
-     * The current cursor of the sample.
+     * 0-127
+     * This parameter sets the volume of the right delay. Higher values result in a louder
+     * right delay.
      */
-    cursor: number;
+    levelRight: number;
     /**
-     * Fills the output buffer with raw sample data using a given interpolation.
-     * @param sampleCount The amount of samples to write into the buffer.
-     * @param tuningRatio the tuning ratio to apply.
-     * @param outputBuffer The output buffer to write to.
+     * 0-127
+     * (-64)-63
+     * This parameter affects the number of times the delay will repeat. With a value of 0,
+     * the delay will not repeat. With higher values there will be more repeats.
+     * With negative (-) values, the center delay will be fed back with inverted phase.
+     * Negative values are effective with short delay times.
      */
-    abstract process(sampleCount: number, tuningRatio: number, outputBuffer: Float32Array): boolean;
-}
-
-/**
- * Voice.ts
- * purpose: prepares Voices from sample and generator data
- */
-
-/**
- * Voice represents a single instance of the
- * SoundFont2 synthesis model.
- * That is:
- * A wavetable oscillator (sample)
- * A volume envelope (volEnv)
- * A modulation envelope (modEnv)
- * Generators (generators and modulatedGenerators)
- * Modulators (modulators)
- * And MIDI params such as channel, MIDI note, velocity
- */
-declare class Voice {
+    feedback: number;
     /**
-     * All oscillators currently available to the voice.
+     * 0-127
+     * This parameter sets the amount of delay sound that is sent to the reverb.
+     * Higher values result in more sound being sent.
      */
-    readonly oscillators: Record<InterpolationType, WavetableOscillator>;
+    sendLevelToReverb: number;
+}
+interface DelayProcessor extends DelayProcessorSnapshot {
     /**
-     * The oscillator currently used by this voice.
+     * Process the effect and ADDS it to the output.
+     * @param input The input buffer to process. It always starts at index 0.
+     * @param outputLeft The left output buffer.
+     * @param outputRight The right output buffer.
+     * @param outputReverb The mono input for reverb. It always starts at index 0.
+     * @param startIndex The index to start mixing at into the output buffers.
+     * @param sampleCount The amount of samples to mix.
      */
-    wavetable: WavetableOscillator;
+    process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, startIndex: number, sampleCount: number): void;
     /**
-     * Lowpass filter applied to the voice.
+     * Gets a synthesizer from this effect processor instance.
      */
-    readonly filter: LowpassFilter;
+    getSnapshot(): DelayProcessorSnapshot;
+}
+interface InsertionProcessor {
     /**
-     * The unmodulated (copied to) generators of the voice.
+     * The EFX type of this processor, stored as MSB << | LSB.
+     * For example 0x30, 0x10 is 0x3010
      */
-    readonly generators: Int16Array<ArrayBuffer>;
+    readonly type: number;
     /**
-     * The generators in real-time, affected by modulators.
-     * This is used during rendering.
+     * 0-1 (floating point)
+     * This parameter sets the amount of insertion sound that will be sent to the reverb.
+     * Higher values result in more sound being sent.
      */
-    readonly modulatedGenerators: Int16Array<ArrayBuffer>;
+    sendLevelToReverb: number;
     /**
-     * The voice's modulators.
+     * 0-1 (floating point)
+     * This parameter sets the amount of insertion sound that will be sent to the chorus.
+     * Higher values result in more sound being sent.
      */
-    modulators: Modulator[];
+    sendLevelToChorus: number;
     /**
-     * The current values for the respective modulators.
-     * If there are more modulators, the array must be resized.
+     * 0-1 (floating point)
+     * This parameter sets the amount of insertion sound that will be sent to the delay.
+     * Higher values result in more sound being sent.
      */
-    modulatorValues: Int16Array<ArrayBuffer>;
+    sendLevelToDelay: number;
     /**
-     * Modulation envelope.
+     * Resets the params to their default values.
+     * This does not need to reset send levels.
      */
-    readonly modEnv: ModulationEnvelope;
+    reset(): void;
     /**
-     * Volume envelope.
+     * Sets an EFX parameter.
+     * @param parameter The parameter number (0x03-0x16).
+     * @param value The new value (0-127).
      */
-    readonly volEnv: VolumeEnvelope;
+    setParameter(parameter: number, value: number): void;
     /**
-     * Resonance offset, it is affected by the default resonant modulator
+     * Process the effect and ADDS it to the output.
+     * @param inputLeft The left input buffer to process. It always starts at index 0.
+     * @param inputRight The right input buffer to process. It always starts at index 0.
+     * @param outputLeft The left output buffer.
+     * @param outputRight The right output buffer.
+     * @param outputReverb The mono input for reverb. It always starts at index 0.
+     * @param outputChorus The mono input for chorus. It always starts at index 0.
+     * @param outputDelay The mono input for delay. It always starts at index 0.
+     * @param startIndex The index to start mixing at into the output buffers.
+     * @param sampleCount The amount of samples to mix.
      */
-    resonanceOffset: number;
+    process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, outputChorus: Float32Array, outputDelay: Float32Array, startIndex: number, sampleCount: number): void;
+}
+interface InsertionProcessorSnapshot {
+    type: number;
     /**
-     * Priority of the voice. Used for stealing.
+     * 20 parameters for the effect, 255 means "no change" + 3 effect sends (index 20, 21, 22)
      */
-    priority: number;
+    params: Uint8Array;
     /**
-     * If the voice is currently active.
-     * If not, it can be used.
+     * A boolean list for channels that have the insertion effect enabled.
      */
-    isActive: boolean;
+    channels: boolean[];
+}
+type InsertionProcessorConstructor = new (sampleRate: number, maxBufferSize: number) => InsertionProcessor;
+
+type SynthSystem = "gm" | "gm2" | "gs" | "xg";
+interface NoteOnCallback {
+    /** The MIDI note number. */
+    midiNote: number;
+    /** The MIDI channel number. */
+    channel: number;
+    /** The velocity of the note. */
+    velocity: number;
+}
+interface NoteOffCallback {
+    /** The MIDI note number. */
+    midiNote: number;
+    /** The MIDI channel number. */
+    channel: number;
+}
+interface DrumChangeCallback {
+    /** The MIDI channel number. */
+    channel: number;
+    /** Indicates if the channel is a drum channel. */
+    isDrumChannel: boolean;
+}
+interface ProgramChangeCallback extends MIDIPatch {
+    /** The MIDI channel number. */
+    channel: number;
+}
+interface ControllerChangeCallback {
+    /** The MIDI channel number. */
+    channel: number;
+    /** The controller number. */
+    controllerNumber: MIDIController;
+    /** The value of the controller. */
+    controllerValue: number;
+}
+interface MuteChannelCallback {
+    /** The MIDI channel number. */
+    channel: number;
+    /** Indicates if the channel is muted. */
+    isMuted: boolean;
+}
+interface PresetListEntry extends MIDIPatchNamed {
     /**
-     * Indicates if the voice has rendered at least one buffer.
-     * Used for exclusive class to prevent killing voices set on the same note.
+     * Indicates if this preset is any kind of drum preset.
      */
-    hasRendered: boolean;
+    isAnyDrums: boolean;
+}
+/**
+ * A list of preset changes, each with a name, bank, and program number.
+ */
+type PresetList = PresetListEntry[];
+/**
+ * The synthesizer display system exclusive data, EXCLUDING THE F0 BYTE!
+ */
+type SynthDisplayCallback = number[];
+interface PitchWheelCallback {
+    /** The MIDI channel number. */
+    channel: number;
     /**
-     * Indicates if the voice is in the release phase.
+     * The unsigned 14-bit value of the pitch: 0 - 16383.
      */
-    isInRelease: boolean;
+    pitch: number;
     /**
-     * Indicates if the voice is currently held by the sustain pedal.
+     * If the pitch wheel was note-specific, this is the MIDI note number that was altered. Set to -1 otherwise.
      */
-    isHeld: boolean;
+    midiNote: number;
+}
+interface ChannelPressureCallback {
+    /** The MIDI channel number. */
+    channel: number;
+    /** The pressure value. */
+    pressure: number;
+}
+interface PolyPressureCallback {
+    /** The MIDI channel number. */
+    channel: number;
+    /** The MIDI note number. */
+    midiNote: number;
+    /** The pressure value. */
+    pressure: number;
+}
+/**
+ * The error message for sound bank errors.
+ */
+type SoundBankErrorCallback = Error;
+interface StopAllCallback {
     /**
-     * MIDI channel number of the voice.
+     * The MIDI channel number.
      */
     channel: number;
     /**
-     * Velocity of the note.
+     * If the channel was force stopped. (no release time)
      */
-    velocity: number;
+    force: boolean;
+}
+type MasterParameterChangeCallback = {
+    [P in keyof MasterParameterType]: {
+        /**
+         * The parameter that was changed.
+         */
+        parameter: P;
+        /**
+         * The new value of this parameter.
+         */
+        value: MasterParameterType[P];
+    };
+}[keyof MasterParameterType];
+interface ChannelPropertyChangeCallback {
     /**
-     * MIDI note number.
+     * The channel number of the new property.
      */
-    midiNote: number;
+    channel: number;
     /**
-     * The root key of the voice.
+     * The updated property.
      */
-    rootKey: number;
+    property: ChannelProperty;
+}
+type FXType<K> = Exclude<keyof K, "process" | "getSnapshot"> | "macro";
+type EffectChangeCallback = {
     /**
-     * Target key for the note.
+     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
      */
-    targetKey: number;
+    effect: "reverb";
     /**
-     * The pressure of the voice
+     * The parameter type or "macro".
      */
-    pressure: number;
+    parameter: FXType<ReverbProcessor>;
     /**
-     * Linear gain of the voice. Used with Key Modifiers.
+     * The new 7-bit value.
      */
-    gainModifier: number;
+    value: number;
+} | {
     /**
-     * Looping mode of the sample:
-     * 0 - no loop
-     * 1 - loop
-     * 2 - UNOFFICIAL: polyphone 2.4 added start on release
-     * 3 - loop then play when released
+     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
      */
-    loopingMode: SampleLoopingMode;
+    effect: "chorus";
     /**
-     * Start time of the voice, absolute.
+     * The parameter type or "macro".
      */
-    startTime: number;
+    parameter: FXType<ChorusProcessor>;
     /**
-     * Start time of the release phase, absolute.
+     * The new 7-bit value.
      */
-    releaseStartTime: number;
+    value: number;
+} | {
     /**
-     * Current tuning in cents.
+     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
      */
-    tuningCents: number;
+    effect: "delay";
     /**
-     * Current calculated tuning. (as in ratio)
+     * The parameter type or "macro".
      */
-    tuningRatio: number;
+    parameter: FXType<DelayProcessor>;
     /**
-     * From -500 to 500. Used for smoothing.
+     * The new 7-bit value.
      */
-    currentPan: number;
+    value: number;
+} | {
     /**
-     * If MIDI Tuning Standard is already applied (at note-on time),
-     * this will be used to take the values at real-time tuning as "midiNote"
-     * property contains the tuned number.
-     * see  SpessaSynth#29 comment by @paulikaro
+     * The effect that was changed, "reverb", "chorus", "delay" or "insertion"
      */
-    realKey: number;
+    effect: "insertion";
     /**
-     * Initial key to glide from, MIDI Note number. If -1, the portamento is OFF.
+     * The parameter that was changed. This maps to GS address map at addr2 = 0x03.
+     * See SC-8850 Manual p.237,
+     * for example:
+     * - 0x0 - EFX type, the value is 16 bit in this special case. Note that this resets the parameters!
+     * - 0x3 - EFX param 1
+     * - 0x16 - EFX param 20 (usually level)
+     * - 0x17 - EFX send to reverb
+     *
+     * There are two exceptions:
+     * - -1 - the channel has ENABLED the effect.
+     * - -2 - the channel has DISABLED the effect.
+     * For both of these cases, `value` is the channel number.
      */
-    portamentoFromKey: number;
+    parameter: number;
     /**
-     * Duration of the linear glide, in seconds.
+     * The new value for the parameter.
      */
-    portamentoDuration: number;
+    value: number;
+};
+interface SynthProcessorEventData {
     /**
-     * From -500 to 500, where zero means disabled (use the channel pan). Used for random pan.
+     * This event fires when a note is played.
      */
-    overridePan: number;
+    noteOn: NoteOnCallback;
     /**
-     * In cents, used for drum tuning.
+     * This event fires when a note is released.
      */
-    pitchOffset: number;
+    noteOff: NoteOffCallback;
     /**
-     * Reverb send of the voice, used for drum parts, otherwise 1.
+     * This event fires when a pitch wheel is changed.
      */
-    reverbSend: number;
+    pitchWheel: PitchWheelCallback;
     /**
-     * Chorus send of the voice, used for drum parts, otherwise 1.
+     * This event fires when a controller is changed.
      */
-    chorusSend: number;
+    controllerChange: ControllerChangeCallback;
     /**
-     * Delay send of the voice, used for drum parts, otherwise 1.
+     * This event fires when a program is changed.
      */
-    delaySend: number;
+    programChange: ProgramChangeCallback;
     /**
-     * Exclusive class number for hi-hats etc.
+     * This event fires when a channel pressure is changed.
      */
-    exclusiveClass: number;
+    channelPressure: ChannelPressureCallback;
     /**
-     * In timecents, where zero means disabled (use the modulatedGenerators table).
-     * Used for exclusive notes and killing notes.
+     * This event fires when a polyphonic pressure is changed.
      */
-    overrideReleaseVolEnv: number;
-    vibLfoPhase: number;
-    vibLfoStartTime: number;
-    modLfoPhase: number;
-    modLfoStartTime: number;
-    constructor(sampleRate: number);
+    polyPressure: PolyPressureCallback;
     /**
-     * Computes a given modulator
-     * @param controllerTable all midi controllers as 14bit values + the non-controller indexes, starting at 128
-     * @param pitchWheel the pitch wheel value, as channel determines if it's a per-note or a global value.
-     * @param modulatorIndex the modulator to compute
-     * @returns the computed value
+     * This event fires when a drum channel is changed.
      */
-    computeModulator(this: Voice, controllerTable: Int16Array, pitchWheel: number, modulatorIndex: number): number;
+    drumChange: DrumChangeCallback;
     /**
-     * Releases the voice as exclusiveClass.
+     * This event fires when all notes on a channel are stopped.
      */
-    exclusiveRelease(currentTime: number, minExclusiveLength?: number): void;
+    stopAll: StopAllCallback;
     /**
-     * Stops the voice
-     * @param currentTime
-     * @param minNoteLength minimum note length in seconds
+     * This event fires when a new channel is created. There is no data for this event.
      */
-    releaseVoice(currentTime: number, minNoteLength?: number): void;
-    setup(currentTime: number, channel: number, midiNote: number, velocity: number, realKey: number): void;
-}
-
-declare class ModulatorSource {
+    newChannel: void;
     /**
-     * If this field is set to false, the controller should be mapped with a minimum value of 0 and a maximum value of 1. This is also
-     * called Unipolar. Thus, it behaves similar to the Modulation Wheel controller of the MIDI specification.
-     *
-     * If this field is set to true, the controller sound be mapped with a minimum value of -1 and a maximum value of 1. This is also
-     * called Bipolar. Thus, it behaves similar to the Pitch Wheel controller of the MIDI specification.
+     * This event fires when a channel is muted or unmuted.
      */
-    isBipolar: boolean;
+    muteChannel: MuteChannelCallback;
     /**
-     * If this field is set true, the direction of the controller should be from the maximum value to the minimum value. So, for
-     * example, if the controller source is Key Number, then a Key Number value of 0 corresponds to the maximum possible
-     * controller output, and the Key Number value of 127 corresponds to the minimum possible controller input.
+     * This event fires when the preset list is changed.
      */
-    isNegative: boolean;
+    presetListChange: PresetList;
     /**
-     * The index of the source.
-     * It can point to one of the MIDI controllers or one of the predefined sources, depending on the 'isCC' flag.
+     * This event fires when all controllers on all channels are reset. There is no data for this event.
      */
-    index: ModulatorSourceIndex;
+    allControllerReset: void;
     /**
-     * If this field is set to true, the MIDI Controller Palette is selected. The ‘index’ field value corresponds to one of the 128
-     * MIDI Continuous Controller messages as defined in the MIDI specification.
+     * This event fires when a sound bank parsing error occurs.
      */
-    isCC: boolean;
+    soundBankError: SoundBankErrorCallback;
     /**
-     * This field specifies how the minimum value approaches the maximum value.
+     * This event fires when the synthesizer receives a display message.
      */
-    curveType: ModulatorCurveType;
-    constructor(index?: ModulatorSourceIndex, curveType?: ModulatorCurveType, isCC?: boolean, isBipolar?: boolean, isNegative?: boolean);
-    private get sourceName();
-    private get curveTypeName();
-    static fromSourceEnum(sourceEnum: number): ModulatorSource;
+    synthDisplay: SynthDisplayCallback;
     /**
-     * Copies the modulator source.
-     * @param source The source to copy from.
-     * @returns the copied source.
+     * This event fires when a master parameter changes.
      */
-    static copyFrom(source: ModulatorSource): ModulatorSource;
-    toString(): string;
-    toSourceEnum(): number;
-    isIdentical(source: ModulatorSource): boolean;
+    masterParameterChange: MasterParameterChangeCallback;
     /**
-     * Gets the current value from this source.
-     * @param midiControllers The MIDI controller + modulator source array.
-     * @param pitchWheel the pitch wheel value, as channel determines if it's a per-note or a global value.
-     * @param voice The voice to get the data for.
+     * This event fires when a channel property changes.
      */
-    getValue(midiControllers: Int16Array, pitchWheel: number, voice: Voice): number;
-}
-
-/**
- * Returned structure containing extended SF2 chunks.
- */
-interface ExtendedSF2Chunks {
+    channelPropertyChange: ChannelPropertyChangeCallback;
     /**
-     * The PDTA part of the chunk.
+     * This event fires when an effect processor is modified.
      */
-    pdta: IndexedByteArray;
+    effectChange: EffectChangeCallback;
+}
+type SynthProcessorEvent = {
+    [K in keyof SynthProcessorEventData]: {
+        type: K;
+        data: SynthProcessorEventData[K];
+    };
+}[keyof SynthProcessorEventData];
+interface SynthMethodOptions {
     /**
-     * The XDTA (https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md) part of the chunk.
+     * The audio context time when the event should execute, in seconds.
      */
-    xdta: IndexedByteArray;
+    time: number;
 }
 /**
- * Write indexes for tracking writing a SoundFont file.
+ * Looping mode of the sample.
+ * 0 - no loop.
+ * 1 - loop.
+ * 2 - UNOFFICIAL: polyphone 2.4 added start on release.
+ * 3 - loop then play when released.
  */
-interface SoundFontWriteIndexes {
-    /**
-     * Generator start index.
-     */
-    gen: number;
+type SampleLoopingMode = 0 | 1 | 2 | 3;
+/**
+ * A list of voices for a given key:velocity.
+ */
+type CachedVoiceList = CachedVoice[];
+interface ChannelProperty {
     /**
-     * Modulator start index.
+     * The channel's current voice amount.
      */
-    mod: number;
+    voicesAmount: number;
     /**
-     * Zone start index.
+     * The channel's current pitch wheel 0 - 16384.
      */
-    bag: number;
+    pitchWheel: number;
     /**
-     * Preset/instrument start index.
+     * The pitch wheel's range, in semitones.
      */
-    hdr: number;
-}
-
-declare class Modulator {
+    pitchWheelRange: number;
     /**
-     * The generator destination of this modulator.
+     * Indicates whether the channel is muted.
      */
-    destination: GeneratorType;
+    isMuted: boolean;
     /**
-     * The transform amount for this modulator.
+     * Indicates whether the channel is a drum channel.
      */
-    transformAmount: number;
+    isDrum: boolean;
     /**
-     * The transform type for this modulator.
+     * Indicates whether the channel uses an insertion effect.
+     * This means that there will be no separate dry output for processSplit().
      */
-    transformType: ModulatorTransformType;
+    isEFX: boolean;
     /**
-     * Indicates if the given modulator is chorus or reverb effects modulator.
-     * This is done to simulate BASSMIDI effects behavior:
-     * - defaults to 1000 transform amount rather than 200
-     * - values can be changed, but anything above 200 is 1000
-     * (except for values above 1000, they are copied directly)
-     * - all values below are multiplied by 5 (200 * 5 = 1000)
-     * - still can be disabled if the soundfont has its own modulator curve
-     * - this fixes the very low amount of reverb by default and doesn't break soundfonts
+     * The channel's transposition, in semitones.
      */
-    readonly isEffectModulator: boolean;
+    transposition: number;
+}
+interface SynthProcessorOptions {
     /**
-     * The default resonant modulator does not affect the filter gain.
-     * Neither XG nor GS responded to cc #74 in that way.
+     * The maximum buffer size the synthesizer can render at once.
+     * Attempting to `.process()` more samples than this will result in an error.
+     * Defaults to 128.
      */
-    readonly isDefaultResonantModulator: boolean;
+    maxBufferSize: number;
     /**
-     * The primary source of this modulator.
+     * Indicates if the event system is enabled. This can be changed later.
      */
-    readonly primarySource: ModulatorSource;
+    enableEventSystem: boolean;
     /**
-     * The secondary source of this modulator.
+     * The initial time of the synth, in seconds.
      */
-    readonly secondarySource: ModulatorSource;
+    initialTime: number;
     /**
-     * Creates a new SF2 Modulator
+     * Indicates if the effects are enabled. This can be changed later.
      */
-    constructor(primarySource?: ModulatorSource, secondarySource?: ModulatorSource, destination?: GeneratorType, amount?: number, transformType?: ModulatorTransformType, isEffectModulator?: boolean, isDefaultResonantModulator?: boolean);
-    private get destinationName();
+    enableEffects: boolean;
     /**
-     * Checks if the pair of modulators is identical (in SF2 terms)
-     * @param mod1 modulator 1
-     * @param mod2 modulator 2
-     * @param checkAmount if the amount should be checked too.
-     * @returns if they are identical
+     * Reverb processor for the synthesizer. Leave undefined to use the default.
      */
-    static isIdentical(mod1: Modulator, mod2: Modulator, checkAmount?: boolean): boolean;
+    reverbProcessor?: ReverbProcessor;
     /**
-     * Copies a modulator.
-     * @param mod The modulator to copy.
-     * @returns The copied modulator.
+     * Chorus processor for the synthesizer. Leave undefined to use the default.
      */
-    static copyFrom(mod: Modulator): Modulator;
-    toString(): string;
-    write(modData: IndexedByteArray, indexes?: SoundFontWriteIndexes): void;
+    chorusProcessor?: ChorusProcessor;
     /**
-     * Sums transform and create a NEW modulator
-     * @param modulator the modulator to sum with
-     * @returns the new modulator
+     * Delay processor for the synthesizer. Leave undefined to use the default.
      */
-    sumTransform(modulator: Modulator): Modulator;
+    delayProcessor?: DelayProcessor;
 }
-
-declare class Generator {
-    /**
-     * The generator's SF2 type.
-     */
-    generatorType: GeneratorType;
+/**
+ * The master parameters of the synthesizer.
+ */
+interface MasterParameterType {
     /**
-     * The generator's 16-bit value.
+     * The master gain, from 0 to any number. 1 is 100% volume.
      */
-    generatorValue: number;
+    masterGain: number;
     /**
-     * Constructs a new generator
-     * @param type generator type
-     * @param value generator value
-     * @param validate if the limits should be validated and clamped.
+     * The master pan, from -1 (left) to 1 (right). 0 is center.
      */
-    constructor(type: GeneratorType, value: number, validate?: boolean);
-    write(genData: IndexedByteArray): void;
-    toString(): string;
-}
-
-declare class BasicZone {
+    masterPan: number;
     /**
-     * The zone's velocity range.
-     * min -1 means that it is a default value
+     * The maximum number of voices that can be played at once.
+     *
+     * @remarks
+     * Increasing this value causes memory allocation for more voices.
+     * It is recommended to set it at the beginning, before rendering audio to avoid GC.
+     * Decreasing it does not cause memory usage change, so it's fine to use.
      */
-    velRange: GenericRange;
+    voiceCap: number;
     /**
-     * The zone's key range.
-     * min -1 means that it is a default value.
+     * Enabling this parameter will cause a new voice allocation when the voice cap is hit, rather than stealing existing voices.
+     *
+     * @remarks
+     * This is not recommended in real-time environments.
      */
-    keyRange: GenericRange;
+    autoAllocateVoices: boolean;
     /**
-     * The zone's generators.
+     * The interpolation type used for sample playback.
      */
-    generators: Generator[];
+    interpolationType: InterpolationType;
     /**
-     * The zone's modulators.
+     * The MIDI system used by the synthesizer for bank selects and system exclusives. (GM, GM2, GS, XG)
      */
-    modulators: Modulator[];
-    get hasKeyRange(): boolean;
-    get hasVelRange(): boolean;
+    midiSystem: SynthSystem;
     /**
-     * The current tuning in cents, taking in both coarse and fine generators.
+     * Indicates whether the synthesizer is in monophonic retrigger mode.
+     * This emulates the behavior of Microsoft GS Wavetable Synth,
+     * Where a new note will kill the previous one if it is still playing.
      */
-    get fineTuning(): number;
+    monophonicRetriggerMode: boolean;
     /**
-     * The current tuning in cents, taking in both coarse and fine generators.
+     * The reverb gain, from 0 to any number. 1 is 100% reverb.
      */
-    set fineTuning(tuningCents: number);
+    reverbGain: number;
     /**
-     * Adds to a given generator, or its default value.
-     * @param type the generator type.
-     * @param value the value to add.
-     * @param validate if the value should be clamped to allowed limits.
+     * If the synthesizer should prevent editing of the reverb parameters.
+     * This effect is modified using MIDI system exclusive messages, so
+     * the recommended use case would be setting
+     * the reverb parameters then locking it to prevent changes by MIDI files.
      */
-    addToGenerator(type: GeneratorType, value: number, validate?: boolean): void;
+    reverbLock: boolean;
     /**
-     * Sets a generator to a given value if preset, otherwise adds a new one.
-     * @param type the generator type.
-     * @param value the value to set. Set to null to remove this generator (set as "unset").
-     * @param validate if the value should be clamped to allowed limits.
+     * The chorus gain, from 0 to any number. 1 is 100% chorus.
      */
-    setGenerator(type: GeneratorType, value: number | null, validate?: boolean): void;
+    chorusGain: number;
     /**
-     * Adds generators to the zone.
-     * @param generators the generators to add.
+     * If the synthesizer should prevent editing of the chorus parameters.
+     * This effect is modified using MIDI system exclusive messages, so
+     * the recommended use case would be setting
+     * the chorus parameters then locking it to prevent changes by MIDI files.
      */
-    addGenerators(...generators: Generator[]): void;
+    chorusLock: boolean;
     /**
-     * Adds modulators to the zone.
-     * @param modulators the modulators to add.
+     * The delay gain, from 0 to any number. 1 is 100% delay.
      */
-    addModulators(...modulators: Modulator[]): void;
+    delayGain: number;
     /**
-     * Gets a generator value.
-     * @param generatorType the generator type.
-     * @param notFoundValue if the generator is not found, this value is returned. A default value can be passed here, or null for example,
-     * to check if the generator is set.
+     * If the synthesizer should prevent editing of the delay parameters.
+     * This effect is modified using MIDI system exclusive messages, so
+     * the recommended use case would be setting
+     * the delay parameters then locking it to prevent changes by MIDI files.
      */
-    getGenerator<K>(generatorType: GeneratorType, notFoundValue: number | K): number | K;
-    copyFrom(zone: BasicZone): void;
+    delayLock: boolean;
     /**
-     * Filters the generators and prepends the range generators.
+     * If the synthesizer should prevent changing the insertion effect type and parameters (including enabling/disabling it on channels).
+     * This effect is modified using MIDI system exclusive messages, so
+     * the recommended use case would be setting
+     * the insertion effect type and parameters then locking it to prevent changes by MIDI files.
      */
-    getWriteGenerators(bank: BasicSoundBank): Generator[];
-}
-
-declare class BasicGlobalZone extends BasicZone {
-}
-
-declare class BasicInstrumentZone extends BasicZone {
+    insertionEffectLock: boolean;
     /**
-     * The instrument this zone belongs to.
+     * If the synthesizer should prevent editing of the drum parameters.
+     * These params are modified using MIDI system exclusive messages or NRPN, so
+     * the recommended use case would be setting
+     * the drum parameters then locking it to prevent changes by MIDI files.
      */
-    readonly parentInstrument: BasicInstrument;
+    drumLock: boolean;
     /**
-     * For tracking on the individual zone level, since multiple presets can refer to the same instrument.
+     * If the synthesizer should prevent applying the custom vibrato.
+     * This effect is modified using NRPN, so
+     * the recommended use case would be setting
+     * the custom vibrato then locking it to prevent changes by MIDI files.
      */
-    useCount: number;
+    customVibratoLock: boolean;
     /**
-     * Creates a new instrument zone.
-     * @param instrument The parent instrument.
-     * @param sample The sample to use in this zone.
+     * If the synthesizer should prevent changing any parameters via NRPN.
+     * This includes the custom vibrato parameters.
      */
-    constructor(instrument: BasicInstrument, sample: BasicSample);
+    nprnParamLock: boolean;
     /**
-     * Zone's sample.
+     * Forces note killing instead of releasing. Improves performance in black MIDIs.
      */
-    private _sample;
+    blackMIDIMode: boolean;
     /**
-     * Zone's sample.
+     * The global transposition in semitones. It can be decimal to provide microtonal tuning.
      */
-    get sample(): BasicSample;
+    transposition: number;
     /**
-     * Sets a sample for this zone.
-     * @param sample the sample to set.
+     * Synthesizer's device ID for system exclusive messages. Set to -1 to accept all.
      */
-    set sample(sample: BasicSample);
-    getWriteGenerators(bank: BasicSoundBank): Generator[];
+    deviceID: number;
 }
 
-declare class BasicPresetZone extends BasicZone {
+/**
+ * Wavetable_oscillator.ts
+ * purpose: plays back raw audio data at an arbitrary playback rate
+ */
+declare abstract class WavetableOscillator {
     /**
-     * The preset this zone belongs to.
+     * Is the loop on?
      */
-    readonly parentPreset: BasicPreset;
+    isLooping: boolean;
     /**
-     * Creates a new preset zone.
-     * @param preset the preset this zone belongs to.
-     * @param instrument the instrument to use in this zone.
+     * Sample data of the voice.
      */
-    constructor(preset: BasicPreset, instrument: BasicInstrument);
+    sampleData?: Float32Array;
     /**
-     * Zone's instrument.
+     * Playback step (rate) for sample pitch correction.
      */
-    private _instrument;
+    playbackStep: number;
     /**
-     * Zone's instrument.
+     * Start position of the loop.
      */
-    get instrument(): BasicInstrument;
+    loopStart: number;
     /**
-     * Zone's instrument.
+     * End position of the loop.
      */
-    set instrument(instrument: BasicInstrument);
-    getWriteGenerators(bank: BasicSoundBank): Generator[];
-}
-
-declare class BasicPreset implements MIDIPatchNamed {
+    loopEnd: number;
     /**
-     * The parent soundbank instance
-     * Currently used for determining default modulators and XG status
+     * Length of the loop.
+     * @private
      */
-    readonly parentSoundBank: BasicSoundBank;
+    loopLength: number;
     /**
-     * The preset's name
+     * End position of the sample.
      */
-    name: string;
-    program: number;
-    bankMSB: number;
-    bankLSB: number;
-    isGMGSDrum: boolean;
+    end: number;
     /**
-     * The preset's zones
+     * The current cursor of the sample.
      */
-    zones: BasicPresetZone[];
+    cursor: number;
     /**
-     * Preset's global zone
+     * Fills the output buffer with raw sample data using a given interpolation.
+     * @param sampleCount The amount of samples to write into the buffer.
+     * @param tuningRatio the tuning ratio to apply.
+     * @param outputBuffer The output buffer to write to.
      */
-    readonly globalZone: BasicGlobalZone;
+    abstract process(sampleCount: number, tuningRatio: number, outputBuffer: Float32Array): boolean;
+}
+
+/**
+ * Voice.ts
+ * purpose: prepares Voices from sample and generator data
+ */
+
+/**
+ * Voice represents a single instance of the
+ * SoundFont2 synthesis model.
+ * That is:
+ * A wavetable oscillator (sample)
+ * A volume envelope (volEnv)
+ * A modulation envelope (modEnv)
+ * Generators (generators and modulatedGenerators)
+ * Modulators (modulators)
+ * And MIDI params such as channel, MIDI note, velocity
+ */
+declare class Voice {
     /**
-     * Unused metadata
+     * All oscillators currently available to the voice.
      */
-    library: number;
+    readonly oscillators: Record<InterpolationType, WavetableOscillator>;
     /**
-     * Unused metadata
+     * The oscillator currently used by this voice.
      */
-    genre: number;
+    wavetable: WavetableOscillator;
     /**
-     * Unused metadata
+     * Lowpass filter applied to the voice.
      */
-    morphology: number;
+    readonly filter: LowpassFilter;
     /**
-     * Creates a new preset representation.
-     * @param parentSoundBank the sound bank this preset belongs to.
-     * @param globalZone optional, a global zone to use.
+     * The unmodulated (copied to) generators of the voice.
      */
-    constructor(parentSoundBank: BasicSoundBank, globalZone?: BasicGlobalZone);
-    get isXGDrums(): boolean;
+    readonly generators: Int16Array<ArrayBuffer>;
     /**
-     * Checks if this preset is a drum preset
+     * The generators in real-time, affected by modulators.
+     * This is used during rendering.
      */
-    get isAnyDrums(): boolean;
-    private static isInRange;
-    private static addUniqueModulators;
-    private static subtractRanges;
+    readonly modulatedGenerators: Int16Array<ArrayBuffer>;
     /**
-     * Unlinks everything from this preset.
+     * The voice's modulators.
      */
-    delete(): void;
+    modulators: VoiceModulator[];
     /**
-     * Deletes an instrument zone from this preset.
-     * @param index the zone's index to delete.
+     * The current values for the respective modulators.
+     * If there are more modulators, the array must be resized.
      */
-    deleteZone(index: number): void;
+    modulatorValues: Int16Array<ArrayBuffer>;
     /**
-     * Creates a new preset zone and returns it.
-     * @param instrument the instrument to use in the zone.
+     * Modulation envelope.
      */
-    createZone(instrument: BasicInstrument): BasicPresetZone;
+    readonly modEnv: ModulationEnvelope;
     /**
-     * Preloads (loads and caches synthesis data) for a given key range.
+     * Volume envelope.
      */
-    preload(keyMin: number, keyMax: number): void;
+    readonly volEnv: VolumeEnvelope;
     /**
-     * Checks if the bank and program numbers are the same for the given preset as this one.
-     * @param preset The preset to check.
+     * Resonance offset, it is affected by the default resonant modulator
      */
-    matches(preset: MIDIPatch): boolean;
+    resonanceOffset: number;
     /**
-     * Returns the voice synthesis data for this preset.
-     * @param midiNote the MIDI note number.
-     * @param velocity the MIDI velocity.
-     * @returns the returned sound data.
+     * Priority of the voice. Used for stealing.
      */
-    getVoiceParameters(midiNote: number, velocity: number): VoiceParameters[];
+    priority: number;
     /**
-     * BankMSB:bankLSB:program:isGMGSDrum
+     * If the voice is currently active.
+     * If not, it can be used.
      */
-    toMIDIString(): string;
-    toString(): string;
+    isActive: boolean;
     /**
-     * Combines preset into an instrument, flattening the preset zones into instrument zones.
-     * This is a really complex function that attempts to work around the DLS limitations of only having the instrument layer.
-     * @returns The instrument containing the flattened zones. In theory, it should exactly the same as this preset.
+     * Indicates if the voice has rendered at least one buffer.
+     * Used for exclusive class to prevent killing voices set on the same note.
      */
-    toFlattenedInstrument(): BasicInstrument;
+    hasRendered: boolean;
     /**
-     * Writes the SF2 header
-     * @param phdrData
-     * @param index
+     * Indicates if the voice is in the release phase.
      */
-    write(phdrData: ExtendedSF2Chunks, index: number): void;
-}
-
-/**
- * Represents a single instrument
- */
-declare class BasicInstrument {
+    isInRelease: boolean;
     /**
-     * The instrument's name
+     * Indicates if the voice is currently held by the sustain pedal.
      */
-    name: string;
+    isHeld: boolean;
     /**
-     * The instrument's zones
+     * MIDI channel number of the voice.
+     */
+    channel: number;
+    /**
+     * Velocity of the note.
+     */
+    velocity: number;
+    /**
+     * MIDI note number.
      */
-    zones: BasicInstrumentZone[];
+    midiNote: number;
     /**
-     * Instrument's global zone
+     * The root key of the voice.
      */
-    readonly globalZone: BasicGlobalZone;
+    rootKey: number;
     /**
-     * Instrument's linked presets (the presets that use it)
-     * note that duplicates are allowed since one preset can use the same instrument multiple times.
+     * Target key for the note.
      */
-    readonly linkedTo: BasicPreset[];
+    targetKey: number;
     /**
-     * How many presets is this instrument used by
+     * The pressure of the voice
      */
-    get useCount(): number;
+    pressure: number;
     /**
-     * Creates a new instrument zone and returns it.
-     * @param sample The sample to use in the zone.
+     * Linear gain of the voice. Used with Key Modifiers.
      */
-    createZone(sample: BasicSample): BasicInstrumentZone;
+    gainModifier: number;
     /**
-     * Links the instrument ta a given preset
-     * @param preset the preset to link to
+     * Looping mode of the sample:
+     * 0 - no loop
+     * 1 - loop
+     * 2 - UNOFFICIAL: polyphone 2.4 added start on release
+     * 3 - loop then play when released
      */
-    linkTo(preset: BasicPreset): void;
+    loopingMode: SampleLoopingMode;
     /**
-     * Unlinks the instrument from a given preset
-     * @param preset the preset to unlink from
+     * Start time of the voice, absolute.
      */
-    unlinkFrom(preset: BasicPreset): void;
-    deleteUnusedZones(): void;
-    delete(): void;
+    startTime: number;
     /**
-     * Deletes a given instrument zone if it has no uses
-     * @param index the index of the zone to delete
-     * @param force ignores the use count and deletes forcibly
-     * @returns if the zone has been deleted
+     * Start time of the release phase, absolute.
      */
-    deleteZone(index: number, force?: boolean): boolean;
+    releaseStartTime: number;
     /**
-     * Globalizes the instrument *in-place.*
-     * This means trying to move as many generators and modulators
-     * to the global zone as possible to reduce clutter and the count of parameters.
+     * Current tuning in cents.
      */
-    globalize(): void;
-    write(instData: ExtendedSF2Chunks, index: number): void;
-}
-
-declare class BasicSample {
+    tuningCents: number;
     /**
-     * The sample's name.
+     * Current calculated tuning. (as in ratio)
      */
-    name: string;
+    tuningRatio: number;
     /**
-     * Sample rate in Hz.
+     * From -500 to 500. Used for smoothing.
      */
-    sampleRate: number;
+    currentPan: number;
     /**
-     * Original pitch of the sample as a MIDI note number.
+     * If MIDI Tuning Standard is already applied (at note-on time),
+     * this will be used to take the values at real-time tuning as "midiNote"
+     * property contains the tuned number.
+     * see  SpessaSynth#29 comment by @paulikaro
      */
-    originalKey: number;
+    realKey: number;
     /**
-     * Pitch correction, in cents. Can be negative.
+     * Initial key to glide from, MIDI Note number. If -1, the portamento is OFF.
      */
-    pitchCorrection: number;
+    portamentoFromKey: number;
     /**
-     * Linked sample, unused if mono.
+     * Duration of the linear glide, in seconds.
      */
-    linkedSample?: BasicSample;
+    portamentoDuration: number;
     /**
-     * The type of the sample.
+     * From -500 to 500, where zero means disabled (use the channel pan). Used for random pan.
      */
-    sampleType: SampleType;
+    overridePan: number;
     /**
-     * Relative to the start of the sample in sample points.
+     * In cents, used for drum tuning.
      */
-    loopStart: number;
+    pitchOffset: number;
     /**
-     * Relative to the start of the sample in sample points.
+     * Reverb send of the voice, used for drum parts, otherwise 1.
      */
-    loopEnd: number;
+    reverbSend: number;
     /**
-     * Sample's linked instruments (the instruments that use it)
-     * note that duplicates are allowed since one instrument can use the same sample multiple times.
+     * Chorus send of the voice, used for drum parts, otherwise 1.
      */
-    linkedTo: BasicInstrument[];
+    chorusSend: number;
     /**
-     * Indicates if the data was overridden, so it cannot be copied back unchanged.
+     * Delay send of the voice, used for drum parts, otherwise 1.
      */
-    protected dataOverridden: boolean;
+    delaySend: number;
     /**
-     * The compressed sample data if the sample has been compressed.
+     * Exclusive class number for hi-hats etc.
      */
-    protected compressedData?: Uint8Array;
+    exclusiveClass: number;
     /**
-     * The sample's audio data.
+     * In timecents, where zero means disabled (use the modulatedGenerators table).
+     * Used for exclusive notes and killing notes.
      */
-    protected audioData?: Float32Array;
+    overrideReleaseVolEnv: number;
+    vibLfoPhase: number;
+    vibLfoStartTime: number;
+    modLfoPhase: number;
+    modLfoStartTime: number;
+    constructor(sampleRate: number);
     /**
-     * The basic representation of a sample
-     * @param sampleName The sample's name
-     * @param sampleRate The sample's rate in Hz
-     * @param originalKey The sample's pitch as a MIDI note number
-     * @param pitchCorrection The sample's pitch correction in cents
-     * @param sampleType The sample's type, an enum that can indicate SF3
-     * @param loopStart The sample's loop start relative to the sample start in sample points
-     * @param loopEnd The sample's loop end relative to the sample start in sample points
+     * Releases the voice as exclusiveClass.
      */
-    constructor(sampleName: string, sampleRate: number, originalKey: number, pitchCorrection: number, sampleType: SampleType, loopStart: number, loopEnd: number);
+    exclusiveRelease(currentTime: number, minExclusiveLength?: number): void;
     /**
-     * Indicates if the sample is compressed using vorbis SF3.
+     * Stops the voice
+     * @param currentTime
+     * @param minNoteLength minimum note length in seconds
      */
-    get isCompressed(): boolean;
+    releaseVoice(currentTime: number, minNoteLength?: number): void;
+    setup(currentTime: number, channel: number, midiNote: number, velocity: number, realKey: number): void;
+}
+
+declare class ModulatorSource {
     /**
-     * If the sample is linked to another sample.
+     * If this field is set to false, the controller should be mapped with a minimum value of 0 and a maximum value of 1. This is also
+     * called Unipolar. Thus, it behaves similar to the Modulation Wheel controller of the MIDI specification.
+     *
+     * If this field is set to true, the controller sound be mapped with a minimum value of -1 and a maximum value of 1. This is also
+     * called Bipolar. Thus, it behaves similar to the Pitch Wheel controller of the MIDI specification.
      */
-    get isLinked(): boolean;
+    isBipolar: boolean;
     /**
-     * The sample's use count
+     * If this field is set true, the direction of the controller should be from the maximum value to the minimum value. So, for
+     * example, if the controller source is Key Number, then a Key Number value of 0 corresponds to the maximum possible
+     * controller output, and the Key Number value of 127 corresponds to the minimum possible controller input.
      */
-    get useCount(): number;
+    isNegative: boolean;
     /**
-     * Get raw data for writing the file, either a compressed bit stream or signed 16-bit little endian PCM data.
-     * @param allowVorbis if vorbis file data is allowed.
-     * @return either s16le or vorbis data.
+     * The index of the source.
+     * It can point to one of the MIDI controllers or one of the predefined sources, depending on the 'isCC' flag.
      */
-    getRawData(allowVorbis: boolean): Uint8Array;
+    index: ModulatorSourceIndex;
     /**
-     * Resamples the audio data to a given sample rate.
+     * If this field is set to true, the MIDI Controller Palette is selected. The ‘index’ field value corresponds to one of the 128
+     * MIDI Continuous Controller messages as defined in the MIDI specification.
      */
-    resampleData(newSampleRate: number): void;
+    isCC: boolean;
     /**
-     * Compresses the audio data
-     * @param encodeVorbis the compression function to use when compressing
+     * This field specifies how the minimum value approaches the maximum value.
      */
-    compressSample(encodeVorbis: SampleEncodingFunction): Promise<void>;
+    curveType: ModulatorCurveType;
+    constructor(index?: ModulatorSourceIndex, curveType?: ModulatorCurveType, isCC?: boolean, isBipolar?: boolean, isNegative?: boolean);
+    private get sourceName();
+    private get curveTypeName();
+    static fromSourceEnum(sourceEnum: number): ModulatorSource;
     /**
-     * Sets the sample type and unlinks if needed.
-     * @param type The type to set it to.
+     * Copies the modulator source.
+     * @param source The source to copy from.
+     * @returns the copied source.
      */
-    setSampleType(type: SampleType): void;
+    static copyFrom(source: ModulatorSource): ModulatorSource;
+    toString(): string;
+    toSourceEnum(): number;
+    isIdentical(source: ModulatorSource): boolean;
     /**
-     * Unlinks the sample from its stereo link if it has any.
+     * Gets the current value from this source.
+     * @param midiControllers The MIDI controller + modulator source array.
+     * @param pitchWheel the pitch wheel value, as channel determines if it's a per-note or a global value.
+     * @param voice The voice to get the data for.
      */
-    unlinkSample(): void;
+    getValue(midiControllers: Int16Array, pitchWheel: number, voice: Voice): number;
+}
+
+declare class Modulator {
     /**
-     * Links a stereo sample.
-     * @param sample the sample to link to.
-     * @param type either left, right or linked.
+     * The generator destination of this modulator.
      */
-    setLinkedSample(sample: BasicSample, type: SampleType): void;
+    destination: GeneratorType;
     /**
-     * Links the sample to a given instrument
-     * @param instrument the instrument to link to
+     * The transform amount for this modulator.
      */
-    linkTo(instrument: BasicInstrument): void;
+    transformAmount: number;
     /**
-     * Unlinks the sample from a given instrument
-     * @param instrument the instrument to unlink from
+     * The transform type for this modulator.
      */
-    unlinkFrom(instrument: BasicInstrument): void;
+    transformType: ModulatorTransformType;
     /**
-     * Get the float32 audio data.
-     * Note that this either decodes the compressed data or passes the ready sampleData.
-     * If neither are set then it will throw an error!
-     * @returns the audio data
+     * The primary source of this modulator.
      */
-    getAudioData(): Float32Array;
+    readonly primarySource: ModulatorSource;
     /**
-     * Replaces the audio data *in-place*.
-     * @param audioData The new audio data as Float32.
-     * @param sampleRate The new sample rate, in Hertz.
+     * The secondary source of this modulator.
      */
-    setAudioData(audioData: Float32Array, sampleRate: number): void;
+    readonly secondarySource: ModulatorSource;
     /**
-     * Replaces the audio with a compressed data sample and flags the sample as compressed
-     * @param data the new compressed data
+     * Creates a new SF2 Modulator
      */
-    setCompressedData(data: Uint8Array): void;
+    constructor(primarySource?: ModulatorSource, secondarySource?: ModulatorSource, destination?: GeneratorType, amount?: number, transformType?: ModulatorTransformType);
+    private get destinationName();
     /**
-     * Encodes s16le sample
-     * @return the encoded data
+     * Checks if the pair of modulators is identical (in SF2 terms)
+     * @param mod1 modulator 1
+     * @param mod2 modulator 2
+     * @param checkAmount if the amount should be checked too.
+     * @returns if they are identical
      */
-    protected encodeS16LE(): IndexedByteArray;
+    static isIdentical(mod1: Modulator, mod2: Modulator, checkAmount?: boolean): boolean;
     /**
-     * Decode binary vorbis into a float32 pcm
+     * Copies a modulator.
+     * @param mod The modulator to copy.
+     * @returns The copied modulator.
      */
-    protected decodeVorbis(): Float32Array;
-}
-declare class EmptySample extends BasicSample {
+    static copyFrom(mod: Modulator): Modulator;
+    toString(): string;
+    write(modData: IndexedByteArray, indexes?: SoundFontWriteIndexes): void;
     /**
-     * A simplified class for creating samples.
+     * Sums transform and create a NEW modulator
+     * @param modulator the modulator to sum with
+     * @returns the new modulator
      */
-    constructor();
+    sumTransform(modulator: Modulator): Modulator;
 }
 
 /**
@@ -2805,7 +2817,7 @@ declare class DynamicModulatorSystem {
      * The current dynamic modulator list.
      */
     modulatorList: {
-        mod: Modulator;
+        mod: VoiceModulator;
         id: string;
     }[];
     active: boolean;
@@ -3488,6 +3500,7 @@ declare class MIDIChannel {
      * A small optimization that disables applying overrides until at least one is set.
      */
     protected generatorOverridesEnabled: boolean;
+    protected readonly computeModulator: (voice: Voice, pitchWheel: number, modulatorIndex: number) => number;
     protected readonly computeModulators: (voice: Voice, sourceUsesCC?: 0 | 1 | -1 | undefined, sourceIndex?: number | undefined) => void;
     /**
      * For tracking voice count changes
@@ -5066,14 +5079,4 @@ declare class SpessaSynthSequencer {
     protected sendMIDIPitchWheel(channel: number, pitch: number): void;
 }
 
-declare class SoundBankLoader {
-    /**
-     * Loads a sound bank from a file buffer.
-     * @param buffer The binary file buffer to load.
-     * @returns The loaded sound bank, a BasicSoundBank instance.
-     */
-    static fromArrayBuffer(buffer: ArrayBuffer): BasicSoundBank;
-    private static loadDLS;
-}
-
 export { ALL_CHANNELS_OR_DIFFERENT_ACTION, BasicGlobalZone, BasicInstrument, BasicInstrumentZone, BasicMIDI, BasicPreset, BasicPresetZone, BasicSample, BasicSoundBank, BasicZone, CONTROLLER_TABLE_SIZE, CUSTOM_CONTROLLER_TABLE_SIZE, type CachedVoiceList, type ChannelPressureCallback, type ChannelProperty, type ChannelPropertyChangeCallback, ChannelSnapshot, type ChorusProcessor, type ChorusProcessorSnapshot, type ControllerChangeCallback, type CustomController, DEFAULT_MASTER_PARAMETERS, DEFAULT_PERCUSSION, DEFAULT_WAV_WRITE_OPTIONS, type DLSChunkFourCC, type DLSDestination, type DLSInfoFourCC, type DLSLoop, type DLSLoopType, DLSLoopTypes, type DLSSource, type DLSTransform, type DLSWriteOptions, type DataEntryState, type DelayProcessor, type DelayProcessorSnapshot, type DesiredChannelTranspose, type DesiredControllerChange, type DesiredProgramChange, type DrumChangeCallback, type EffectChangeCallback, EmptySample, type FourCC, GENERATORS_AMOUNT, Generator, type GeneratorType, type GenericBankInfoFourCC, type GenericRIFFFourCC, type GenericRange, IndexedByteArray, type InsertionProcessor, type InsertionProcessorConstructor, type InsertionProcessorSnapshot, type InterpolationType, KeyModifier, MAX_GENERATOR, MIDIBuilder, type MIDIController, type MIDIFormat, type MIDILoop, type MIDILoopType, MIDIMessage, type MIDIMessageType, type MIDIPatch, type MIDIPatchNamed, MIDIPatchTools, MIDITrack, type MasterParameterChangeCallback, type MasterParameterType, Modulator, type ModulatorCurveType, ModulatorSource, type ModulatorSourceEnum, type ModulatorSourceIndex, type ModulatorTransformType, type MuteChannelCallback, NON_CC_INDEX_OFFSET, type NoteOffCallback, type NoteOnCallback, type NoteTime, type PitchWheelCallback, type PolyPressureCallback, type PresetList, type PresetListEntry, type ProgramChangeCallback, type ProgressFunction, type RMIDIWriteOptions, type RMIDInfoData, type RMIDInfoFourCC, type ReverbProcessor, type ReverbProcessorSnapshot, type SF2ChunkFourCC, type SF2InfoFourCC, type SF2VersionTag, type SampleEncodingFunction, type SampleLoopingMode, type SampleType, type SequencerEvent, type SequencerEventData, type SoundBankErrorCallback, type SoundBankInfoData, type SoundBankInfoFourCC, SoundBankLoader, type SoundBankManagerListEntry, type SoundFont2WriteOptions, SpessaSynthCoreUtils, SpessaSynthLogging, SpessaSynthProcessor, SpessaSynthSequencer, type StopAllCallback, type SynthMethodOptions, type SynthProcessorEvent, type SynthProcessorEventData, type SynthProcessorOptions, type SynthSystem, SynthesizerSnapshot, type TempoChange, type VoiceParameters, type WaveMetadata, type WaveWriteOptions, audioToWav, customControllers, customResetArray, dataEntryStates, defaultGeneratorValues, defaultMIDIControllerValues, dlsDestinations, dlsSources, drumReverbResetArray, generatorLimits, generatorTypes, interpolationTypes, midiControllers, midiMessageTypes, modulatorCurveTypes, modulatorSources, modulatorTransformTypes, sampleTypes, setResetValue };