spessasynth_core 4.0.24 → 4.1.0

package/dist/index.d.ts

@@ -15,15 +15,6 @@ declare class IndexedByteArray extends Uint8Array {
     slice(start?: number, end?: number): IndexedByteArray;
 }
 
-/**
- * Writes an audio into a valid WAV file.
- * @param audioData the audio data channels.
- * @param sampleRate the sample rate, in Hertz.
- * @param options Additional options for writing the file.
- * @returns the binary file.
- */
-declare function audioToWav(audioData: Float32Array[], sampleRate: number, options?: Partial<WaveWriteOptions>): ArrayBuffer;
-
 /**
  * Reads number as Big endian.
  * @param dataArray the array to read from.
@@ -69,10 +60,19 @@ declare function SpessaSynthGroup(...message: unknown[]): void;
 declare function SpessaSynthGroupCollapsed(...message: unknown[]): void;
 declare function SpessaSynthGroupEnd(): void;
 
+/**
+ * Writes an audio into a valid WAV file.
+ * @param audioData the audio data channels.
+ * @param sampleRate the sample rate, in Hertz.
+ * @param options Additional options for writing the file.
+ * @returns the binary file.
+ */
+declare function audioToWav(audioData: Float32Array[], sampleRate: number, options?: Partial<WaveWriteOptions>): ArrayBuffer;
+
 /**
  * All SoundFont2 Generator enumerations.
  */
-declare const generatorTypes: {
+declare const generatorTypes: Readonly<{
     readonly INVALID: -1;
     readonly startAddrsOffset: 0;
     readonly endAddrOffset: 1;
@@ -137,19 +137,20 @@ declare const generatorTypes: {
     readonly endOper: 60;
     readonly vibLfoToVolume: 61;
     readonly vibLfoToFilterFc: 62;
-};
+}>;
 type GeneratorType = (typeof generatorTypes)[keyof typeof generatorTypes];
 declare const GENERATORS_AMOUNT: number;
 declare const MAX_GENERATOR: number;
 /**
- * Min: minimum value, max: maximum value, def: default value, nrpn: nrpn scale...
+ * Min: minimum value, max: maximum value, def: default value, nrpn: nrpn scale
  */
-declare const generatorLimits: {
+declare const generatorLimits: Readonly<Record<number, {
     min: number;
     max: number;
     def: number;
     nrpn: number;
-}[];
+}>>;
+declare const defaultGeneratorValues: Int16Array<ArrayBuffer>;
 
 declare const sampleTypes: {
     readonly monoSample: 1;
@@ -245,6 +246,281 @@ declare const DLSLoopTypes: {
 };
 type DLSLoopType = (typeof DLSLoopTypes)[keyof typeof DLSLoopTypes];
 
+declare class LowpassFilter {
+    /**
+     * Cached coefficient calculations.
+     * stored as cachedCoefficients[resonanceCb + currentInitialFc * 961].
+     */
+    private static cachedCoefficients;
+    /**
+     * For smoothing the filter cutoff frequency.
+     */
+    private static smoothingConstant;
+    /**
+     * Resonance in centibels.
+     */
+    resonanceCb: number;
+    /**
+     * Current cutoff frequency in absolute cents.
+     */
+    currentInitialFc: number;
+    /**
+     * Filter coefficient 1.
+     */
+    private a0;
+    /**
+     * Filter coefficient 2.
+     */
+    private a1;
+    /**
+     * Filter coefficient 3.
+     */
+    private a2;
+    /**
+     * Filter coefficient 4.
+     */
+    private a3;
+    /**
+     * Filter coefficient 5.
+     */
+    private a4;
+    /**
+     * Input history 1.
+     */
+    private x1;
+    /**
+     * Input history 2.
+     */
+    private x2;
+    /**
+     * Output history 1.
+     */
+    private y1;
+    /**
+     * Output history 2.
+     */
+    private y2;
+    /**
+     * For tracking the last cutoff frequency in the apply method, absolute cents.
+     * Set to infinity to force recalculation.
+     */
+    private lastTargetCutoff;
+    /**
+     * Used for tracking if the filter has been initialized.
+     */
+    private initialized;
+    /**
+     * Filter's sample rate in Hz.
+     */
+    private readonly sampleRate;
+    /**
+     * Maximum cutoff frequency in Hz.
+     * This is used to prevent aliasing and ensure the filter operates within the valid frequency range.
+     */
+    private readonly maxCutoff;
+    /**
+     * Initializes a new instance of the filter.
+     * @param sampleRate the sample rate of the audio engine in Hz.
+     */
+    constructor(sampleRate: number);
+    static initCache(sampleRate: number): void;
+    init(): void;
+    /**
+     * Applies the lowpass filter to the output buffer of a voice.
+     * @param sampleCount The amount of samples to write.
+     * @param voice The voice to apply the filter to.
+     * @param outputBuffer The output buffer to filter.
+     * @param fcOffset The frequency excursion in cents to apply to the filter.
+     */
+    process(sampleCount: number, voice: Voice, outputBuffer: Float32Array, fcOffset: number): void;
+    /**
+     * Calculates the filter coefficients based on the current resonance and cutoff frequency and caches them.
+     * @param cutoffCents The cutoff frequency in cents.
+     */
+    calculateCoefficients(cutoffCents: number): void;
+}
+
+/**
+ * VOL ENV STATES:
+ * 0 - delay
+ * 1 - attack
+ * 2 - hold/peak
+ * 3 - decay
+ * 4 - sustain
+ * release indicates by isInRelease property
+ */
+type VolumeEnvelopeState = 0 | 1 | 2 | 3 | 4;
+declare class VolumeEnvelope {
+    /**
+     * The sample rate in Hz.
+     */
+    readonly sampleRate: number;
+    /**
+     * The current attenuation of the envelope in cB.
+     */
+    attenuationCb: number;
+    /**
+     * The current stage of the volume envelope.
+     */
+    state: VolumeEnvelopeState;
+    /**
+     * The envelope's current time in samples.
+     */
+    private sampleTime;
+    /**
+     * The dB attenuation of the envelope when it entered the release stage.
+     */
+    private releaseStartCb;
+    /**
+     * The time in samples relative to the start of the envelope.
+     */
+    private releaseStartTimeSamples;
+    /**
+     * The attack duration in samples.
+     */
+    private attackDuration;
+    /**
+     * The decay duration in samples.
+     */
+    private decayDuration;
+    /**
+     * The release duration in samples.
+     */
+    private releaseDuration;
+    /**
+     * The voice's sustain amount in cB.
+     */
+    private sustainCb;
+    /**
+     * The time in samples to the end of delay stage, relative to the start of the envelope.
+     */
+    private delayEnd;
+    /**
+     * The time in samples to the end of attack stage, relative to the start of the envelope.
+     */
+    private attackEnd;
+    /**
+     * The time in samples to the end of hold stage, relative to the start of the envelope.
+     */
+    private holdEnd;
+    /**
+     * The time in samples to the end of decay stage, relative to the start of the envelope.
+     */
+    private decayEnd;
+    /**
+     * If the volume envelope has ever entered the release phase.
+     * @private
+     */
+    private enteredRelease;
+    /**
+     * If sustain stage is silent,
+     * then we can turn off the voice when it is silent.
+     * We can't do that with modulated as it can silence the volume and then raise it again, and the voice must keep playing.
+     */
+    private canEndOnSilentSustain;
+    private readonly gainSmoothing;
+    private currentGain;
+    /**
+     * @param sampleRate Hz
+     */
+    constructor(sampleRate: number);
+    /**
+     * Applies volume envelope gain to the given output buffer.
+     * Essentially we use approach of 100dB is silence, 0dB is peak.
+     * @param sampleCount the amount of samples to write
+     * @param buffer the audio buffer to modify
+     * @param gainTarget the gain target to smooth.
+     * @param centibelOffset the centibel offset to apply.
+     * @returns if the voice is still active
+     */
+    process(sampleCount: number, buffer: Float32Array, gainTarget: number, centibelOffset: number): boolean;
+    /**
+     * Starts the release phase in the envelope.
+     * @param voice the voice this envelope belongs to.
+     */
+    startRelease(voice: Voice): void;
+    /**
+     * Initialize the volume envelope
+     * @param voice The voice this envelope belongs to
+     */
+    init(voice: Voice): void;
+    private timecentsToSamples;
+    private releasePhase;
+    private delayPhase;
+    private attackPhase;
+    private holdPhase;
+    private decayPhase;
+    private sustainPhase;
+}
+
+declare class ModulationEnvelope {
+    /**
+     * The attack duration, in seconds.
+     */
+    private attackDuration;
+    /**
+     * The decay duration, in seconds.
+     */
+    private decayDuration;
+    /**
+     * The hold duration, in seconds.
+     */
+    private holdDuration;
+    /**
+     * Release duration, in seconds.
+     */
+    private releaseDuration;
+    /**
+     * The sustain level 0-1.
+     */
+    private sustainLevel;
+    /**
+     * Delay phase end time in seconds, absolute (audio context time).
+     */
+    private delayEnd;
+    /**
+     * Attack phase end time in seconds, absolute (audio context time).
+     */
+    private attackEnd;
+    /**
+     * Hold phase end time in seconds, absolute (audio context time).
+     */
+    private holdEnd;
+    /**
+     * The level of the envelope when the release phase starts.
+     */
+    private releaseStartLevel;
+    /**
+     * The current modulation envelope value.
+     */
+    private currentValue;
+    /**
+     * If the modulation envelope has ever entered the release phase.
+     */
+    private enteredRelease;
+    /**
+     * Decay phase end time in seconds, absolute (audio context time).
+     */
+    private decayEnd;
+    /**
+     * Calculates the current modulation envelope value for the given time and voice.
+     * @param voice the voice we are working on.
+     * @param currentTime in seconds.
+     * @returns  mod env value, from 0 to 1.
+     */
+    process(voice: Voice, currentTime: number): number;
+    /**
+     * Starts the release phase in the envelope.
+     * @param voice the voice this envelope belongs to.
+     */
+    startRelease(voice: Voice): void;
+    /**
+     * Initializes the modulation envelope.
+     * @param voice the voice this envelope belongs to.
+     */
+    init(voice: Voice): void;
+}
+
 declare const interpolationTypes: {
     readonly linear: 0;
     readonly nearestNeighbor: 1;
@@ -325,36 +601,254 @@ declare class MIDIPatchTools {
     static sorter(a: MIDIPatch, b: MIDIPatch): number;
 }
 
-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;
+/**
+ * Represents a cached voice
+ */
+declare class CachedVoice {
+    /**
+     * Sample data of this voice.
+     */
+    readonly sampleData: Float32Array;
+    /**
+     * The unmodulated (copied to) generators of the voice.
+     */
+    readonly generators: Int16Array;
+    /**
+     * The voice's modulators.
+     */
+    readonly modulators: Modulator[];
+    /**
+     * Exclusive class number for hi-hats etc.
+     */
+    readonly exclusiveClass: number;
+    /**
+     * Target key of the voice (can be overridden by generators)
+     */
+    readonly targetKey: number;
+    /**
+     * Target velocity of the voice (can be overridden by generators)
+     */
+    readonly velocity: number;
+    /**
+     * MIDI root key of the sample
+     */
+    readonly rootKey: number;
+    /**
+     * Start position of the loop
+     */
+    readonly loopStart: number;
+    /**
+     * End position of the loop
+     */
+    readonly loopEnd: number;
+    /**
+     * Playback step (rate) for sample pitch correction
+     */
+    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 detuneDepth: 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];
+
+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: number;
+    controllerNumber: MIDIController;
     /** The value of the controller. */
     controllerValue: number;
 }
@@ -385,6 +879,10 @@ interface PitchWheelCallback {
      * The unsigned 14-bit value of the pitch: 0 - 16383.
      */
     pitch: number;
+    /**
+     * If the pitch wheel was note-specific, this is the MIDI note number that was altered. Set to -1 otherwise.
+     */
+    midiNote: number;
 }
 interface ChannelPressureCallback {
     /** The MIDI channel number. */
@@ -518,20 +1016,6 @@ interface SynthMethodOptions {
      */
     time: number;
 }
-/**
- * KeyNum: tuning.
- */
-type MTSProgramTuning = MTSNoteTuning[];
-interface MTSNoteTuning {
-    /**
-     * The base MIDI note to use, -1 means no change.
-     */
-    midiNote: number;
-    /**
-     * Additional tuning.
-     */
-    centTuning: number | null;
-}
 /**
  * Looping mode of the sample.
  * 0 - no loop.
@@ -543,7 +1027,7 @@ type SampleLoopingMode = 0 | 1 | 2 | 3;
 /**
  * A list of voices for a given key:velocity.
  */
-type VoiceList = Voice[];
+type CachedVoiceList = CachedVoice[];
 interface ChannelProperty {
     /**
      * The channel's current voice amount.
@@ -637,286 +1121,305 @@ interface MasterParameterType {
 }
 
 /**
- * Sets a master parameter of the synthesizer.
- * @param parameter The type of the master parameter to set.
- * @param value The value to set for the master parameter.
- */
-declare function setMasterParameterInternal<P extends keyof MasterParameterType>(this: SpessaSynthProcessor, parameter: P, value: MasterParameterType[P]): void;
-/**
- * Gets a master parameter of the synthesizer.
- * @param type The type of the master parameter to get.
- * @returns The value of the master parameter.
- */
-declare function getMasterParameterInternal<P extends keyof MasterParameterType>(this: SpessaSynthProcessor, type: P): MasterParameterType[P];
-/**
- * Gets all master parameters of the synthesizer.
- * @returns All the master parameters.
+ * Wavetable_oscillator.ts
+ * purpose: plays back raw audio data at an arbitrary playback rate
  */
-declare function getAllMasterParametersInternal(this: SpessaSynthProcessor): MasterParameterType;
-
-declare class Generator {
+declare abstract class WavetableOscillator {
     /**
-     * The generator's SF2 type.
+     * Is the loop on?
      */
-    generatorType: GeneratorType;
+    isLooping: boolean;
     /**
-     * The generator's 16-bit value.
+     * Sample data of the voice.
      */
-    generatorValue: number;
+    sampleData?: Float32Array;
     /**
-     * Constructs a new generator
-     * @param type generator type
-     * @param value generator value
-     * @param validate if the limits should be validated
+     * Playback step (rate) for sample pitch correction.
      */
-    constructor(type: GeneratorType, value: number, validate?: boolean);
-    write(genData: IndexedByteArray): void;
-    toString(): string;
-}
-
-declare class BasicZone {
+    playbackStep: number;
     /**
-     * The zone's velocity range.
-     * min -1 means that it is a default value
+     * Start position of the loop.
      */
-    velRange: GenericRange;
+    loopStart: number;
     /**
-     * The zone's key range.
-     * min -1 means that it is a default value.
+     * End position of the loop.
      */
-    keyRange: GenericRange;
+    loopEnd: number;
     /**
-     * The zone's generators.
+     * Length of the loop.
+     * @private
      */
-    generators: Generator[];
+    loopLength: number;
     /**
-     * The zone's modulators.
+     * End position of the sample.
      */
-    modulators: Modulator[];
-    get hasKeyRange(): boolean;
-    get hasVelRange(): boolean;
+    end: number;
     /**
-     * The current tuning in cents, taking in both coarse and fine generators.
+     * The current cursor of the sample.
      */
-    get fineTuning(): number;
+    cursor: number;
     /**
-     * The current tuning in cents, taking in both coarse and fine generators.
+     * 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.
      */
-    set fineTuning(tuningCents: number);
+    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 {
     /**
-     * Adds to a given generator, or its default value.
+     * All oscillators currently available to the voice.
      */
-    addToGenerator(type: GeneratorType, value: number, validate?: boolean): void;
+    readonly oscillators: Record<InterpolationType, WavetableOscillator>;
     /**
-     * Sets a generator to a given value if preset, otherwise adds a new one.
+     * The oscillator currently used by this voice.
      */
-    setGenerator(type: GeneratorType, value: number | null, validate?: boolean): void;
+    wavetable: WavetableOscillator;
     /**
-     * Adds generators to the zone.
-     * @param generators
+     * Lowpass filter applied to the voice.
      */
-    addGenerators(...generators: Generator[]): void;
-    addModulators(...modulators: Modulator[]): void;
-    getGenerator<K>(generatorType: GeneratorType, notFoundValue: number | K): number | K;
-    copyFrom(zone: BasicZone): void;
+    readonly filter: LowpassFilter;
     /**
-     * Filters the generators and prepends the range generators.
+     * The unmodulated (copied to) generators of the voice.
      */
-    getWriteGenerators(bank: BasicSoundBank): Generator[];
-}
-
-declare class BasicGlobalZone extends BasicZone {
-}
-
-declare class BasicSample {
+    readonly generators: Int16Array<ArrayBuffer>;
     /**
-     * The sample's name.
+     * The generators in real-time, affected by modulators.
+     * This is used during rendering.
      */
-    name: string;
+    readonly modulatedGenerators: Int16Array<ArrayBuffer>;
     /**
-     * Sample rate in Hz.
+     * The voice's modulators.
      */
-    sampleRate: number;
+    modulators: Modulator[];
     /**
-     * Original pitch of the sample as a MIDI note number.
+     * The current values for the respective modulators.
+     * If there are more modulators, the array must be resized.
      */
-    originalKey: number;
+    modulatorValues: Int16Array<ArrayBuffer>;
     /**
-     * Pitch correction, in cents. Can be negative.
+     * Modulation envelope.
      */
-    pitchCorrection: number;
+    readonly modEnv: ModulationEnvelope;
     /**
-     * Linked sample, unused if mono.
+     * Volume envelope.
      */
-    linkedSample?: BasicSample;
+    readonly volEnv: VolumeEnvelope;
     /**
-     * The type of the sample.
+     * The buffer to use when rendering the voice (to avoid memory allocations)
+     * If the user supplied a larger one, it must be resized.
      */
-    sampleType: SampleType;
+    buffer: Float32Array<ArrayBuffer>;
     /**
-     * Relative to the start of the sample in sample points.
+     * Resonance offset, it is affected by the default resonant modulator
      */
-    loopStart: number;
+    resonanceOffset: number;
     /**
-     * Relative to the start of the sample in sample points.
+     * Priority of the voice. Used for stealing.
      */
-    loopEnd: number;
+    priority: 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.
+     * If the voice is currently active.
+     * If not, it can be used.
      */
-    linkedTo: BasicInstrument[];
+    isActive: boolean;
     /**
-     * Indicates if the data was overridden, so it cannot be copied back unchanged.
+     * Indicates if the voice has rendered at least one buffer.
+     * Used for exclusive class to prevent killing voices set on the same note.
      */
-    protected dataOverridden: boolean;
+    hasRendered: boolean;
     /**
-     * The compressed sample data if the sample has been compressed.
+     * Indicates if the voice is in the release phase.
      */
-    protected compressedData?: Uint8Array;
+    isInRelease: boolean;
     /**
-     * The sample's audio data.
+     * Indicates if the voice is currently held by the sustain pedal.
      */
-    protected audioData?: Float32Array;
+    isHeld: boolean;
     /**
-     * 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
+     * MIDI channel number of the voice.
      */
-    constructor(sampleName: string, sampleRate: number, originalKey: number, pitchCorrection: number, sampleType: SampleType, loopStart: number, loopEnd: number);
+    channel: number;
     /**
-     * Indicates if the sample is compressed using vorbis SF3.
+     * Velocity of the note.
      */
-    get isCompressed(): boolean;
+    velocity: number;
     /**
-     * If the sample is linked to another sample.
+     * MIDI note number.
      */
-    get isLinked(): boolean;
+    midiNote: number;
     /**
-     * The sample's use count
+     * The root key of the voice.
      */
-    get useCount(): number;
+    rootKey: number;
     /**
-     * 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.
+     * Target key for the note.
      */
-    getRawData(allowVorbis: boolean): Uint8Array;
+    targetKey: number;
     /**
-     * Resamples the audio data to a given sample rate.
+     * The pressure of the voice
      */
-    resampleData(newSampleRate: number): void;
+    pressure: number;
     /**
-     * Compresses the audio data
-     * @param encodeVorbis the compression function to use when compressing
+     * Linear gain of the voice. Used with Key Modifiers.
      */
-    compressSample(encodeVorbis: SampleEncodingFunction): Promise<void>;
+    gainModifier: number;
     /**
-     * Sets the sample type and unlinks if needed.
-     * @param type The type to set it 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
      */
-    setSampleType(type: SampleType): void;
+    loopingMode: SampleLoopingMode;
     /**
-     * Unlinks the sample from its stereo link if it has any.
+     * Start time of the voice, absolute.
      */
-    unlinkSample(): void;
+    startTime: number;
     /**
-     * Links a stereo sample.
-     * @param sample the sample to link to.
-     * @param type either left, right or linked.
+     * Start time of the release phase, absolute.
      */
-    setLinkedSample(sample: BasicSample, type: SampleType): void;
+    releaseStartTime: number;
     /**
-     * Links the sample to a given instrument
-     * @param instrument the instrument to link to
+     * Current tuning in cents.
      */
-    linkTo(instrument: BasicInstrument): void;
+    tuningCents: number;
     /**
-     * Unlinks the sample from a given instrument
-     * @param instrument the instrument to unlink from
+     * Current calculated tuning. (as in ratio)
      */
-    unlinkFrom(instrument: BasicInstrument): void;
+    tuningRatio: number;
     /**
-     * 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
+     * From -500 to 500. Used for smoothing.
      */
-    getAudioData(): Float32Array;
+    currentPan: number;
     /**
-     * Replaces the audio data *in-place*.
-     * @param audioData The new audio data as Float32.
-     * @param sampleRate The new sample rate, in Hertz.
+     * 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
      */
-    setAudioData(audioData: Float32Array, sampleRate: number): void;
+    realKey: number;
     /**
-     * Replaces the audio with a compressed data sample and flags the sample as compressed
-     * @param data the new compressed data
+     * Initial key to glide from, MIDI Note number. If -1, the portamento is OFF.
      */
-    setCompressedData(data: Uint8Array): void;
+    portamentoFromKey: number;
     /**
-     * Encodes s16le sample
-     * @return the encoded data
+     * Duration of the linear glide, in seconds.
      */
-    protected encodeS16LE(): IndexedByteArray;
+    portamentoDuration: number;
     /**
-     * Decode binary vorbis into a float32 pcm
+     * From -500 to 500, where zero means disabled (use the channel pan). Used for random pan.
      */
-    protected decodeVorbis(): Float32Array;
-}
-declare class EmptySample extends BasicSample {
+    overridePan: number;
     /**
-     * A simplified class for creating samples.
+     * Exclusive class number for hi-hats etc.
      */
-    constructor();
-}
-
-declare class BasicInstrumentZone extends BasicZone {
+    exclusiveClass: number;
     /**
-     * The instrument this zone belongs to.
+     * In timecents, where zero means disabled (use the modulatedGenerators table).
+     * Used for exclusive notes and killing notes.
      */
-    readonly parentInstrument: BasicInstrument;
+    overrideReleaseVolEnv: number;
+    constructor(sampleRate: number);
     /**
-     * For tracking on the individual zone level, since multiple presets can refer to the same instrument.
+     * 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
      */
-    useCount: number;
+    computeModulator(this: Voice, controllerTable: Int16Array, pitchWheel: number, modulatorIndex: number): number;
     /**
-     * Creates a new instrument zone.
-     * @param instrument The parent instrument.
-     * @param sample The sample to use in this zone.
+     * Releases the voice as exclusiveClass.
      */
-    constructor(instrument: BasicInstrument, sample: BasicSample);
+    exclusiveRelease(currentTime: number, minExclusiveLength?: number): void;
     /**
-     * Zone's sample.
+     * Stops the voice
+     * @param currentTime
+     * @param minNoteLength minimum note length in seconds
      */
-    private _sample;
+    releaseVoice(currentTime: number, minNoteLength?: number): void;
+    setup(currentTime: number, channel: number, midiNote: number, velocity: number, realKey: number): void;
+}
+
+declare class ModulatorSource {
     /**
-     * Zone's 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 sample(): BasicSample;
+    isBipolar: boolean;
     /**
-     * Sets a sample for this zone.
-     * @param sample the sample to set.
+     * 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.
      */
-    set sample(sample: BasicSample);
-    getWriteGenerators(bank: BasicSoundBank): Generator[];
-}
-
-/**
- * Returned structure containing extended SF2 chunks.
- */
-interface ExtendedSF2Chunks {
+    isNegative: boolean;
     /**
-     * The PDTA part of the chunk.
+     * 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.
      */
-    pdta: IndexedByteArray;
+    index: ModulatorSourceIndex;
     /**
-     * The XDTA (https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md) part of the chunk.
+     * 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.
+     */
+    isCC: boolean;
+    /**
+     * This field specifies how the minimum value approaches the maximum value.
+     */
+    curveType: ModulatorCurveType;
+    constructor(index?: ModulatorSourceIndex, curveType?: ModulatorCurveType, isCC?: boolean, isBipolar?: boolean, isNegative?: boolean);
+    private get sourceName();
+    private get curveTypeName();
+    static fromSourceEnum(sourceEnum: number): ModulatorSource;
+    /**
+     * Copies the modulator source.
+     * @param source The source to copy from.
+     * @returns the copied source.
+     */
+    static copyFrom(source: ModulatorSource): ModulatorSource;
+    toString(): string;
+    toSourceEnum(): number;
+    isIdentical(source: ModulatorSource): boolean;
+    /**
+     * 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.
+     */
+    getValue(midiControllers: Int16Array, pitchWheel: number, voice: Voice): number;
+}
+
+/**
+ * Returned structure containing extended SF2 chunks.
+ */
+interface ExtendedSF2Chunks {
+    /**
+     * The PDTA part of the chunk.
+     */
+    pdta: IndexedByteArray;
+    /**
+     * The XDTA (https://github.com/spessasus/soundfont-proposals/blob/main/extended_limits.md) part of the chunk.
      */
     xdta: IndexedByteArray;
 }
@@ -942,62 +1445,175 @@ interface SoundFontWriteIndexes {
     hdr: number;
 }
 
-/**
- * Represents a single instrument
- */
-declare class BasicInstrument {
+declare class Modulator {
     /**
-     * The instrument's name
+     * The generator destination of this modulator.
      */
-    name: string;
+    destination: GeneratorType;
     /**
-     * The instrument's zones
+     * The transform amount for this modulator.
      */
-    zones: BasicInstrumentZone[];
+    transformAmount: number;
     /**
-     * Instrument's global zone
+     * The transform type for this modulator.
      */
-    readonly globalZone: BasicGlobalZone;
+    transformType: ModulatorTransformType;
     /**
-     * Instrument's linked presets (the presets that use it)
-     * note that duplicates are allowed since one preset can use the same instrument multiple times.
+     * 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
      */
-    readonly linkedTo: BasicPreset[];
+    readonly isEffectModulator: boolean;
     /**
-     * How many presets is this instrument used by
+     * The default resonant modulator does not affect the filter gain.
+     * Neither XG nor GS responded to cc #74 in that way.
      */
-    get useCount(): number;
+    readonly isDefaultResonantModulator: boolean;
     /**
-     * Creates a new instrument zone and returns it.
-     * @param sample The sample to use in the zone.
+     * The primary source of this modulator.
      */
-    createZone(sample: BasicSample): BasicInstrumentZone;
+    readonly primarySource: ModulatorSource;
     /**
-     * Links the instrument ta a given preset
-     * @param preset the preset to link to
+     * The secondary source of this modulator.
      */
-    linkTo(preset: BasicPreset): void;
+    readonly secondarySource: ModulatorSource;
     /**
-     * Unlinks the instrument from a given preset
-     * @param preset the preset to unlink from
+     * Creates a new SF2 Modulator
      */
-    unlinkFrom(preset: BasicPreset): void;
-    deleteUnusedZones(): void;
-    delete(): void;
+    constructor(primarySource?: ModulatorSource, secondarySource?: ModulatorSource, destination?: GeneratorType, amount?: number, transformType?: ModulatorTransformType, isEffectModulator?: boolean, isDefaultResonantModulator?: boolean);
+    private get destinationName();
     /**
-     * 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
+     * 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
      */
-    deleteZone(index: number, force?: boolean): boolean;
+    static isIdentical(mod1: Modulator, mod2: Modulator, checkAmount?: boolean): boolean;
     /**
-     * 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.
+     * Copies a modulator.
+     * @param mod The modulator to copy.
+     * @returns The copied modulator.
      */
-    globalize(): void;
-    write(instData: ExtendedSF2Chunks, index: number): void;
+    static copyFrom(mod: Modulator): Modulator;
+    toString(): string;
+    write(modData: IndexedByteArray, indexes?: SoundFontWriteIndexes): void;
+    /**
+     * Sums transform and create a NEW modulator
+     * @param modulator the modulator to sum with
+     * @returns the new modulator
+     */
+    sumTransform(modulator: Modulator): Modulator;
+}
+
+declare class Generator {
+    /**
+     * The generator's SF2 type.
+     */
+    generatorType: GeneratorType;
+    /**
+     * The generator's 16-bit value.
+     */
+    generatorValue: number;
+    /**
+     * Constructs a new generator
+     * @param type generator type
+     * @param value generator value
+     * @param validate if the limits should be validated
+     */
+    constructor(type: GeneratorType, value: number, validate?: boolean);
+    write(genData: IndexedByteArray): void;
+    toString(): string;
+}
+
+declare class BasicZone {
+    /**
+     * The zone's velocity range.
+     * min -1 means that it is a default value
+     */
+    velRange: GenericRange;
+    /**
+     * The zone's key range.
+     * min -1 means that it is a default value.
+     */
+    keyRange: GenericRange;
+    /**
+     * The zone's generators.
+     */
+    generators: Generator[];
+    /**
+     * The zone's modulators.
+     */
+    modulators: Modulator[];
+    get hasKeyRange(): boolean;
+    get hasVelRange(): boolean;
+    /**
+     * The current tuning in cents, taking in both coarse and fine generators.
+     */
+    get fineTuning(): number;
+    /**
+     * The current tuning in cents, taking in both coarse and fine generators.
+     */
+    set fineTuning(tuningCents: number);
+    /**
+     * Adds to a given generator, or its default value.
+     */
+    addToGenerator(type: GeneratorType, value: number, validate?: boolean): void;
+    /**
+     * Sets a generator to a given value if preset, otherwise adds a new one.
+     */
+    setGenerator(type: GeneratorType, value: number | null, validate?: boolean): void;
+    /**
+     * Adds generators to the zone.
+     * @param generators
+     */
+    addGenerators(...generators: Generator[]): void;
+    addModulators(...modulators: Modulator[]): void;
+    getGenerator<K>(generatorType: GeneratorType, notFoundValue: number | K): number | K;
+    copyFrom(zone: BasicZone): void;
+    /**
+     * Filters the generators and prepends the range generators.
+     */
+    getWriteGenerators(bank: BasicSoundBank): Generator[];
+}
+
+declare class BasicGlobalZone extends BasicZone {
+}
+
+declare class BasicInstrumentZone extends BasicZone {
+    /**
+     * The instrument this zone belongs to.
+     */
+    readonly parentInstrument: BasicInstrument;
+    /**
+     * For tracking on the individual zone level, since multiple presets can refer to the same instrument.
+     */
+    useCount: number;
+    /**
+     * Creates a new instrument zone.
+     * @param instrument The parent instrument.
+     * @param sample The sample to use in this zone.
+     */
+    constructor(instrument: BasicInstrument, sample: BasicSample);
+    /**
+     * Zone's sample.
+     */
+    private _sample;
+    /**
+     * Zone's sample.
+     */
+    get sample(): BasicSample;
+    /**
+     * Sets a sample for this zone.
+     * @param sample the sample to set.
+     */
+    set sample(sample: BasicSample);
+    getWriteGenerators(bank: BasicSoundBank): Generator[];
 }
 
 declare class BasicPresetZone extends BasicZone {
@@ -1071,6 +1687,9 @@ declare class BasicPreset implements MIDIPatchNamed {
      * Checks if this preset is a drum preset
      */
     get isAnyDrums(): boolean;
+    private static isInRange;
+    private static addUniqueModulators;
+    private static subtractRanges;
     /**
      * Unlinks everything from this preset.
      */
@@ -1095,12 +1714,12 @@ declare class BasicPreset implements MIDIPatchNamed {
      */
     matches(preset: MIDIPatch): boolean;
     /**
-     * Returns the synthesis data from this preset
-     * @param midiNote the MIDI note number
-     * @param velocity the MIDI velocity
-     * @returns the returned sound data
+     * Returns the voice synthesis data for this preset.
+     * @param midiNote the MIDI note number.
+     * @param velocity the MIDI velocity.
+     * @returns the returned sound data.
      */
-    getSynthesisData(midiNote: number, velocity: number): VoiceSynthesisData[];
+    getVoiceParameters(midiNote: number, velocity: number): VoiceParameters[];
     /**
      * BankMSB:bankLSB:program:isGMGSDrum
      */
@@ -1120,802 +1739,405 @@ declare class BasicPreset implements MIDIPatchNamed {
     write(phdrData: ExtendedSF2Chunks, index: number): void;
 }
 
-declare class SoundBankManager {
+/**
+ * Represents a single instrument
+ */
+declare class BasicInstrument {
     /**
-     * All the sound banks, ordered from the most important to the least.
+     * The instrument's name
      */
-    soundBankList: SoundBankManagerListEntry[];
-    private readonly presetListChangeCallback;
-    private selectablePresetList;
+    name: string;
     /**
-     * @param presetListChangeCallback Supplied by the parent synthesizer class,
-     * this is called whenever the preset list changes.
+     * The instrument's zones
      */
-    constructor(presetListChangeCallback: () => unknown);
-    private _presetList;
+    zones: BasicInstrumentZone[];
     /**
-     * The list of all presets in the sound bank stack.
+     * Instrument's global zone
      */
-    get presetList(): PresetListEntry[];
+    readonly globalZone: BasicGlobalZone;
     /**
-     * The current sound bank priority order.
-     * @returns The IDs of the sound banks in the current order.
+     * Instrument's linked presets (the presets that use it)
+     * note that duplicates are allowed since one preset can use the same instrument multiple times.
      */
-    get priorityOrder(): string[];
+    readonly linkedTo: BasicPreset[];
     /**
-     * The current sound bank priority order.
-     * @param newList The new order of sound bank IDs.
+     * How many presets is this instrument used by
      */
-    set priorityOrder(newList: string[]);
+    get useCount(): number;
     /**
-     * Deletes a given sound bank by its ID.
-     * @param id the ID of the sound bank to delete.
-     */
-    deleteSoundBank(id: string): void;
-    /**
-     * Adds a new sound bank with a given ID, or replaces an existing one.
-     * @param font the sound bank to add.
-     * @param id the ID of the sound bank.
-     * @param bankOffset the bank offset of the sound bank.
-     */
-    addSoundBank(font: BasicSoundBank, id: string, bankOffset?: number): void;
-    /**
-     * Gets a given preset from the sound bank stack.
-     * @param patch The MIDI patch to search for.
-     * @param system The MIDI system to select the preset for.
-     * @returns An object containing the preset and its bank offset.
-     */
-    getPreset(patch: MIDIPatch, system: SynthSystem): BasicPreset;
-    destroy(): void;
-    private generatePresetList;
-}
-
-/**
- * Kills the specified number of voices based on their priority.
- * This function will remove the least important voices from all channels.
- * @param amount The number of voices to remove.
- */
-declare function killVoicesIntenral(this: SpessaSynthProcessor, amount: number): void;
-
-type SysExAcceptedArray = number[] | IndexedByteArray | Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Uint8ClampedArray | Float32Array | Float64Array;
-
-/**
- * Executes a system exclusive message for the synthesizer.
- * @param syx The system exclusive message as an array of bytes.
- * @param channelOffset The channel offset to apply (default is 0).
- * @remarks
- * This is a rather extensive method that handles various system exclusive messages,
- * including Roland GS, MIDI Tuning Standard, and other non-realtime messages.
- */
-declare function systemExclusiveInternal(this: SpessaSynthProcessor, syx: SysExAcceptedArray, channelOffset?: number): void;
-
-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 detuneDepth: 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];
-
-/**
- * Executes a data entry fine (LSB) change for the current channel.
- * @param dataValue The value to set for the data entry fine controller (0-127).
- */
-declare function dataEntryFine(this: MIDIChannel, dataValue: number): void;
-
-/**
- * Handles MIDI controller changes for a channel.
- * @param controllerNumber The MIDI controller number (0-127).
- * @param controllerValue The value of the controller (0-127).
- * @param sendEvent If an event should be emitted.
- * @remarks
- * This function processes MIDI controller changes, updating the channel's
- * midiControllers table and handling special cases like bank select,
- * data entry, and sustain pedal. It also computes modulators for all voices
- * in the channel based on the controller change.
- * If the controller number is greater than 127, it is treated as a channel
- * configuration controller, and the `force` parameter must be set to true
- * to allow changes.
- */
-declare function controllerChange(this: MIDIChannel, controllerNumber: MIDIController, controllerValue: number, sendEvent?: boolean): void;
-
-/**
- * Executes a data entry coarse (MSB) change for the current channel.
- * @param dataValue The value to set for the data entry coarse controller (0-127).
- */
-declare function dataEntryCoarse(this: MIDIChannel, dataValue: number): void;
-
-/**
- * Sends a "MIDI Note on" message and starts a note.
- * @param midiNote The MIDI note number (0-127).
- * @param velocity The velocity of the note (0-127). If less than 1, it will send a note off instead.
- */
-declare function noteOn(this: MIDIChannel, midiNote: number, velocity: number): void;
-
-/**
- * Releases a note by its MIDI note number.
- * If the note is in high performance mode and the channel is not a drum channel,
- * it kills the note instead of releasing it.
- * @param midiNote The MIDI note number to release (0-127).
- */
-declare function noteOff(this: MIDIChannel, midiNote: number): void;
-
-/**
- * Changes the program (preset) of the channel.
- * @param program The program number (0-127) to change to.
- */
-declare function programChange(this: MIDIChannel, program: number): void;
-
-/**
- * A class for dynamic modulators
- * that are assigned for more complex system exclusive messages
- */
-declare class DynamicModulatorSystem {
-    /**
-     * The current dynamic modulator list.
-     */
-    modulatorList: {
-        mod: Modulator;
-        id: string;
-    }[];
-    resetModulators(): void;
-    /**
-     * @param source Like in midiControllers: values below NON_CC_INDEX_OFFSET are CCs,
-     * above are regular modulator sources.
-     * @param destination The generator type to modulate.
-     * @param amount The amount of modulation to apply.
-     * @param isBipolar If true, the modulation is bipolar (ranges from -1 to 1 instead of from 0 to 1).
-     * @param isNegative If true, the modulation is negative (goes from 1 to 0 instead of from 0 to 1).
-     */
-    setModulator(source: ModulatorSourceEnum, destination: GeneratorType, amount: number, isBipolar?: boolean, isNegative?: boolean): void;
-    private getModulatorID;
-    private deleteModulator;
-}
-
-declare class ProtectedSynthValues {
-    /**
-     * This.tunings[program][key] = tuning
-     */
-    readonly tunings: MTSProgramTuning[];
-    masterParameters: MasterParameterType;
-    /**
-     * The volume gain, set by MIDI sysEx
-     */
-    midiVolume: number;
-    /**
-     * Set via system exclusive.
-     * Note: Remember to reset in system reset!
-     */
-    reverbSend: number;
-    /**
-     * Set via system exclusive.
-     * Note: Remember to reset in system reset!
-     */
-    chorusSend: number;
-    /**
-     * The pan of the left channel.
-     */
-    panLeft: number;
-    /**
-     * The pan of the right channel.
-     */
-    panRight: number;
-    /**
-     * Synth's default (reset) preset.
+     * Creates a new instrument zone and returns it.
+     * @param sample The sample to use in the zone.
      */
-    defaultPreset: BasicPreset | undefined;
+    createZone(sample: BasicSample): BasicInstrumentZone;
     /**
-     * Synth's default (reset) drum preset.
+     * Links the instrument ta a given preset
+     * @param preset the preset to link to
      */
-    drumPreset: BasicPreset | undefined;
-    readonly volumeEnvelopeSmoothingFactor: number;
-    readonly panSmoothingFactor: number;
-    readonly filterSmoothingFactor: number;
+    linkTo(preset: BasicPreset): void;
     /**
-     * Calls when an event occurs.
-     * @param eventType The event type.
-     * @param eventData The event data.
+     * Unlinks the instrument from a given preset
+     * @param preset the preset to unlink from
      */
-    eventCallbackHandler: <K extends keyof SynthProcessorEventData>(eventType: K, eventData: SynthProcessorEventData[K]) => unknown;
-    getVoices: (channel: number, midiNote: number, velocity: number, realKey: number) => VoiceList;
-    voiceKilling: (amount: number) => unknown;
+    unlinkFrom(preset: BasicPreset): void;
+    deleteUnusedZones(): void;
+    delete(): void;
     /**
-     * Cached voices for all presets for this synthesizer.
-     * Nesting is calculated in getCachedVoiceIndex, returns a list of voices for this note.
+     * 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
      */
-    cachedVoices: VoiceList[];
-    constructor(eventCallbackHandler: <K extends keyof SynthProcessorEventData>(eventType: K, eventData: SynthProcessorEventData[K]) => unknown, getVoices: (channel: number, midiNote: number, velocity: number, realKey: number) => VoiceList, voiceKillingFunction: (amount: number) => unknown, volumeEnvelopeSmoothingFactor: number, panSmoothingFactor: number, filterSmoothingFactor: number);
+    deleteZone(index: number, force?: boolean): boolean;
     /**
-     * Copied callback so MIDI channels can call it.
+     * 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.
      */
-    callEvent<K extends keyof SynthProcessorEventData>(eventName: K, eventData: SynthProcessorEventData[K]): void;
+    globalize(): void;
+    write(instData: ExtendedSF2Chunks, index: number): void;
 }
 
-/**
- * This class represents a single MIDI Channel within the synthesizer.
- */
-declare class MIDIChannel {
-    readonly midiControllers: Int16Array;
-    /**
-     * An array indicating if a controller, at the equivalent index in the midiControllers array, is locked
-     * (i.e., not allowed changing).
-     * A locked controller cannot be modified.
-     */
-    lockedControllers: boolean[];
-    /**
-     * An array of custom (non-SF2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
-     * Refer to controller_tables.ts for the index definitions.
-     */
-    readonly customControllers: Float32Array;
-    /**
-     * The key shift of the channel (in semitones).
-     */
-    channelTransposeKeyShift: number;
-    /**
-     * An array of octave tuning values for each note on the channel.
-     * Each index corresponds to a note (0 = C, 1 = C#, ..., 11 = B).
-     * Note: Repeated every 12 notes.
-     */
-    channelOctaveTuning: Int8Array;
-    /**
-     * A system for dynamic modulator assignment for advanced system exclusives.
-     */
-    sysExModulators: DynamicModulatorSystem;
-    /**
-     * Indicates whether this channel is a drum channel.
-     */
-    drumChannel: boolean;
+declare class BasicSample {
     /**
-     * Enables random panning for every note played on this channel.
+     * The sample's name.
      */
-    randomPan: boolean;
+    name: string;
     /**
-     * The current state of the data entry for the channel.
+     * Sample rate in Hz.
      */
-    dataEntryState: DataEntryState;
+    sampleRate: number;
     /**
-     * The currently selected MIDI patch of the channel.
-     * Note that the exact matching preset may not be available, but this represents exactly what MIDI asks for.
+     * Original pitch of the sample as a MIDI note number.
      */
-    readonly patch: MIDIPatch;
+    originalKey: number;
     /**
-     * The preset currently assigned to the channel.
+     * Pitch correction, in cents. Can be negative.
      */
-    preset?: BasicPreset;
+    pitchCorrection: number;
     /**
-     * Indicates whether the program on this channel is locked.
+     * Linked sample, unused if mono.
      */
-    lockPreset: boolean;
+    linkedSample?: BasicSample;
     /**
-     * Indicates the MIDI system when the preset was locked.
+     * The type of the sample.
      */
-    lockedSystem: SynthSystem;
+    sampleType: SampleType;
     /**
-     * Indicates whether the GS NRPN parameters are enabled for this channel.
+     * Relative to the start of the sample in sample points.
      */
-    lockGSNRPNParams: boolean;
+    loopStart: number;
     /**
-     * The vibrato settings for the channel.
-     * @property depth - Depth of the vibrato effect in cents.
-     * @property delay - Delay before the vibrato effect starts (in seconds).
-     * @property rate - Rate of the vibrato oscillation (in Hz).
+     * Relative to the start of the sample in sample points.
      */
-    channelVibrato: {
-        delay: number;
-        depth: number;
-        rate: number;
-    };
+    loopEnd: number;
     /**
-     * An array of voices currently active on the channel.
+     * Sample's linked instruments (the instruments that use it)
+     * note that duplicates are allowed since one instrument can use the same sample multiple times.
      */
-    voices: VoiceList;
+    linkedTo: BasicInstrument[];
     /**
-     * An array of voices that are sustained on the channel.
+     * Indicates if the data was overridden, so it cannot be copied back unchanged.
      */
-    sustainedVoices: VoiceList;
+    protected dataOverridden: boolean;
     /**
-     * The channel's number (0-based index)
+     * The compressed sample data if the sample has been compressed.
      */
-    readonly channelNumber: number;
+    protected compressedData?: Uint8Array;
     /**
-     * Parent processor instance.
+     * The sample's audio data.
      */
-    synth: SpessaSynthProcessor;
+    protected audioData?: Float32Array;
     /**
-     * Grants access to protected synth values.
+     * 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
      */
-    synthProps: ProtectedSynthValues;
+    constructor(sampleName: string, sampleRate: number, originalKey: number, pitchCorrection: number, sampleType: SampleType, loopStart: number, loopEnd: number);
     /**
-     * Sends a "MIDI Note on" message and starts a note.
-     * @param midiNote The MIDI note number (0-127).
-     * @param velocity The velocity of the note (0-127). If less than 1, it will send a note off instead.
+     * Indicates if the sample is compressed using vorbis SF3.
      */
-    noteOn: typeof noteOn;
+    get isCompressed(): boolean;
     /**
-     * Releases a note by its MIDI note number.
-     * If the note is in high performance mode and the channel is not a drum channel,
-     * it kills the note instead of releasing it.
-     * @param midiNote The MIDI note number to release (0-127).
+     * If the sample is linked to another sample.
      */
-    noteOff: typeof noteOff;
+    get isLinked(): boolean;
     /**
-     * Changes the program (preset) of the channel.
-     * @param programNumber The program number (0-127) to change to.
+     * The sample's use count
      */
-    programChange: typeof programChange;
-    controllerChange: typeof controllerChange;
+    get useCount(): number;
     /**
-     * Reset all controllers for channel.
-     * This will reset all controllers to their default values,
-     * except for the locked controllers.
+     * 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.
      */
-    readonly resetControllers: typeof resetControllers;
-    readonly resetPreset: typeof resetPreset;
+    getRawData(allowVorbis: boolean): Uint8Array;
     /**
-     * https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
-     * Reset controllers according to RP-15 Recommended Practice.
+     * Resamples the audio data to a given sample rate.
      */
-    readonly resetControllersRP15Compliant: typeof resetControllersRP15Compliant;
+    resampleData(newSampleRate: number): void;
     /**
-     * Reset all parameters to their default values.
-     * This includes NRPN and RPN controllers, data entry state,
-     * and generator overrides and offsets.
+     * Compresses the audio data
+     * @param encodeVorbis the compression function to use when compressing
      */
-    resetParameters: typeof resetParameters;
+    compressSample(encodeVorbis: SampleEncodingFunction): Promise<void>;
     /**
-     * Executes a data entry fine (LSB) change for the current channel.
-     * @param dataValue The value to set for the data entry fine controller (0-127).
+     * Sets the sample type and unlinks if needed.
+     * @param type The type to set it to.
      */
-    dataEntryFine: typeof dataEntryFine;
+    setSampleType(type: SampleType): void;
     /**
-     * Executes a data entry coarse (MSB) change for the current channel.
-     * @param dataValue The value to set for the data entry coarse controller (0-127).
+     * Unlinks the sample from its stereo link if it has any.
      */
-    dataEntryCoarse: typeof dataEntryCoarse;
+    unlinkSample(): void;
     /**
-     * Will be updated every time something tuning-related gets changed.
-     * This is used to avoid a big addition for every voice rendering call.
+     * Links a stereo sample.
+     * @param sample the sample to link to.
+     * @param type either left, right or linked.
      */
-    protected channelTuningCents: number;
+    setLinkedSample(sample: BasicSample, type: SampleType): void;
     /**
-     * An array of offsets generators for SF2 nrpn support.
-     * A value of 0 means no change; -10 means 10 lower, etc.
+     * Links the sample to a given instrument
+     * @param instrument the instrument to link to
      */
-    protected generatorOffsets: Int16Array;
+    linkTo(instrument: BasicInstrument): void;
     /**
-     * A small optimization that disables applying offsets until at least one is set.
+     * Unlinks the sample from a given instrument
+     * @param instrument the instrument to unlink from
      */
-    protected generatorOffsetsEnabled: boolean;
+    unlinkFrom(instrument: BasicInstrument): void;
     /**
-     * An array of override generators for AWE32 support.
-     * A value of 32,767 means unchanged, as it is not allowed anywhere.
+     * 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
      */
-    protected generatorOverrides: Int16Array;
+    getAudioData(): Float32Array;
     /**
-     * A small optimization that disables applying overrides until at least one is set.
+     * Replaces the audio data *in-place*.
+     * @param audioData The new audio data as Float32.
+     * @param sampleRate The new sample rate, in Hertz.
      */
-    protected generatorOverridesEnabled: boolean;
-    protected renderVoice: (voice: Voice, timeNow: number, outputLeft: Float32Array<ArrayBufferLike>, outputRight: Float32Array<ArrayBufferLike>, reverbOutputLeft: Float32Array<ArrayBufferLike>, reverbOutputRight: Float32Array<ArrayBufferLike>, chorusOutputLeft: Float32Array<ArrayBufferLike>, chorusOutputRight: Float32Array<ArrayBufferLike>, startIndex: number, sampleCount: number) => boolean;
-    protected panAndMixVoice: (voice: Voice, inputBuffer: Float32Array<ArrayBufferLike>, outputLeft: Float32Array<ArrayBufferLike>, outputRight: Float32Array<ArrayBufferLike>, reverbLeft: Float32Array<ArrayBufferLike>, reverbRight: Float32Array<ArrayBufferLike>, chorusLeft: Float32Array<ArrayBufferLike>, chorusRight: Float32Array<ArrayBufferLike>, startIndex: number) => void;
-    protected computeModulators: (voice: Voice, sourceUsesCC?: 0 | 1 | -1 | undefined, sourceIndex?: number | undefined) => void;
+    setAudioData(audioData: Float32Array, sampleRate: number): void;
     /**
-     * Constructs a new MIDI channel.
+     * Replaces the audio with a compressed data sample and flags the sample as compressed
+     * @param data the new compressed data
      */
-    constructor(synth: SpessaSynthProcessor, synthProps: ProtectedSynthValues, preset: BasicPreset | undefined, channelNumber: number);
+    setCompressedData(data: Uint8Array): void;
     /**
-     * Indicates whether the channel is muted.
+     * Encodes s16le sample
+     * @return the encoded data
      */
-    protected _isMuted: boolean;
+    protected encodeS16LE(): IndexedByteArray;
     /**
-     * Indicates whether the channel is muted.
+     * Decode binary vorbis into a float32 pcm
      */
-    get isMuted(): boolean;
+    protected decodeVorbis(): Float32Array;
+}
+declare class EmptySample extends BasicSample {
     /**
-     * Indicates whether the sustain (hold) pedal is active.
+     * A simplified class for creating samples.
      */
-    get holdPedal(): boolean;
-    protected get channelSystem(): SynthSystem;
+    constructor();
+}
+
+/**
+ * Midi_message.ts
+ * purpose: contains enums for midi events and controllers and functions to parse them
+ */
+
+declare class MIDIMessage {
     /**
-     * Transposes the channel by given amount of semitones.
-     * @param semitones The number of semitones to transpose the channel by. Can be decimal.
-     * @param force Defaults to false, if true, it will force the transpose even if the channel is a drum channel.
+     * Absolute number of MIDI ticks from the start of the track.
      */
-    transposeChannel(semitones: number, force?: boolean): void;
+    ticks: number;
     /**
-     * Sets the octave tuning for a given channel.
-     * @param tuning The tuning array of 12 values, each representing the tuning for a note in the octave.
-     * @remarks
-     * Cent tunings are relative.
+     * The MIDI message status byte. Note that for meta events, it is the second byte. (not 0xFF)
      */
-    setOctaveTuning(tuning: Int8Array): void;
+    statusByte: MIDIMessageType;
     /**
-     * Sets the modulation depth for the channel.
-     * @param cents The modulation depth in cents to set.
-     * @remarks
-     * This method sets the modulation depth for the channel by converting the given cents value into a
-     * multiplier. The MIDI specification assumes the default modulation depth is 50 cents,
-     * but it may vary for different sound banks.
-     * For example, if you want a modulation depth of 100 cents,
-     * the multiplier will be 2,
-     * which, for a preset with a depth of 50,
-     * will create a total modulation depth of 100 cents.
-     *
+     * Message's binary data
      */
-    setModulationDepth(cents: number): void;
+    data: Uint8Array<ArrayBuffer>;
     /**
-     * Sets the channel's tuning.
-     * @param cents The tuning in cents to set.
-     * @param log If true, logs the change to the console.
+     * Creates a new MIDI message
+     * @param ticks time of this message in absolute MIDI ticks
+     * @param byte the message status byte
+     * @param data the message's binary data
      */
-    setTuning(cents: number, log?: boolean): void;
+    constructor(ticks: number, byte: MIDIMessageType, data: Uint8Array<ArrayBuffer>);
+}
+
+/**
+ * RMIDInfoData type represents metadata for an RMIDI file.
+ */
+interface RMIDInfoData {
     /**
-     * Sets the pitch of the given channel.
-     * @param pitch The pitch (0 - 16384)
+     * The name of the song.
      */
-    pitchWheel(pitch: number): void;
+    name: string;
     /**
-     * Sets the channel pressure (MIDI Aftertouch).
-     * @param pressure the pressure of the channel.
+     * The engineer who worked on the sound bank file.
      */
-    channelPressure(pressure: number): void;
+    engineer: string;
     /**
-     * Sets the pressure of the given note on a specific channel.
-     * This is used for polyphonic pressure (aftertouch).
-     * @param midiNote 0 - 127, the MIDI note number to set the pressure for.
-     * @param pressure 0 - 127, the pressure value to set for the note.
+     * The artist of the MIDI file.
      */
-    polyPressure(midiNote: number, pressure: number): void;
-    setCustomController(type: CustomController, value: number): void;
-    updateChannelTuning(): void;
+    artist: string;
     /**
-     * Renders Float32 audio for this channel.
-     * @param outputLeft the left output buffer.
-     * @param outputRight the right output buffer.
-     * @param reverbOutputLeft left output for reverb.
-     * @param reverbOutputRight right output for reverb.
-     * @param chorusOutputLeft left output for chorus.
-     * @param chorusOutputRight right output for chorus.
-     * @param startIndex start index offset.
-     * @param sampleCount sample count to render.
+     * The album of the song.
      */
-    renderAudio(outputLeft: Float32Array, outputRight: Float32Array, reverbOutputLeft: Float32Array, reverbOutputRight: Float32Array, chorusOutputLeft: Float32Array, chorusOutputRight: Float32Array, startIndex: number, sampleCount: number): void;
+    album: string;
     /**
-     * Locks or unlocks the preset from MIDI program changes.
-     * @param locked If the preset should be locked.
+     * The genre of the song.
      */
-    setPresetLock(locked: boolean): void;
+    genre: string;
     /**
-     * Changes the preset to, or from drums.
-     * Note that this executes a program change.
-     * @param isDrum If the channel should be a drum preset or not.
+     * The image for the file (album cover).
      */
-    setDrums(isDrum: boolean): void;
+    picture: ArrayBuffer;
     /**
-     * Sets the channel to a given MIDI patch.
-     * Note that this executes a program change.
-     * @param patch The MIDI patch to set the channel to.
+     * The comment of the file.
      */
-    setPatch(patch: MIDIPatch): void;
+    comment: string;
     /**
-     * Sets the GM/GS drum flag.
-     * @param drums
+     * The creation date of the file.
      */
-    setGSDrums(drums: boolean): void;
+    creationDate: Date;
     /**
-     * Sets a custom vibrato.
-     * @param depth In cents.
-     * @param rate In Hertz.
-     * @param delay seconds.
+     * The copyright of the file.
      */
-    setVibrato(depth: number, rate: number, delay: number): void;
+    copyright: string;
     /**
-     * Disables and locks all GS NPRN parameters, including the custom vibrato.
+     * The encoding of the RMIDI info.
      */
-    disableAndLockGSNRPN(): void;
-    resetGeneratorOverrides(): void;
-    setGeneratorOverride(gen: GeneratorType, value: number, realtime?: boolean): void;
-    resetGeneratorOffsets(): void;
-    setGeneratorOffset(gen: GeneratorType, value: number): void;
+    infoEncoding: string;
     /**
-     * Stops a note nearly instantly.
-     * @param midiNote The note to stop.
-     * @param releaseTime in timecents, defaults to -12000 (very short release).
+     * The encoding of the MIDI file's text messages.
      */
-    killNote(midiNote: number, releaseTime?: number): void;
+    midiEncoding: string;
     /**
-     * Stops all notes on the channel.
-     * @param force If true, stops all notes immediately, otherwise applies release time.
+     * The software used to write the file.
      */
-    stopAllNotes(force?: boolean): void;
+    software: string;
     /**
-     * Mutes or unmutes a channel.
-     * @param isMuted If the channel should be muted.
+     * The subject of the file.
      */
-    muteChannel(isMuted: boolean): void;
+    subject: string;
+}
+interface TempoChange {
     /**
-     * Sends this channel's property
+     * MIDI ticks of the change, absolute value from the start of the MIDI file.
      */
-    sendChannelProperty(): void;
-    protected setBankMSB(bankMSB: number): void;
-    protected setBankLSB(bankLSB: number): void;
+    ticks: number;
     /**
-     * Sets drums on channel.
+     * New tempo in BPM.
      */
-    protected setDrumFlag(isDrum: boolean): void;
+    tempo: number;
 }
-
-/**
- * Executes a full system reset of all controllers.
- * This will reset all controllers to their default values,
- * except for the locked controllers.
- */
-declare function resetAllControllersInternal(this: SpessaSynthProcessor, system?: SynthSystem): void;
-/**
- * Reset all controllers for channel.
- * This will reset all controllers to their default values,
- * except for the locked controllers.
- */
-declare function resetControllers(this: MIDIChannel, sendCCEvents?: boolean): void;
-declare function resetPreset(this: MIDIChannel): void;
-/**
- * https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
- * Reset controllers according to RP-15 Recommended Practice.
- */
-declare function resetControllersRP15Compliant(this: MIDIChannel): void;
-/**
- * Reset all parameters to their default values.
- * This includes NRPN and RPN controllers, data entry state,
- * and generator overrides and offsets.
- */
-declare function resetParameters(this: MIDIChannel): void;
-
-/**
- * Represents a snapshot of a single channel's state in the synthesizer.
- */
-declare class ChannelSnapshot {
+type MIDILoopType = "soft" | "hard";
+interface MIDILoop {
     /**
-     * The MIDI patch that the channel is using.
+     * Start of the loop, in MIDI ticks.
      */
-    patch: MIDIPatchNamed;
+    start: number;
     /**
-     * Indicates whether the channel's program change is disabled.
+     * End of the loop, in MIDI ticks.
      */
-    lockPreset: boolean;
+    end: number;
     /**
-     * Indicates the MIDI system when the preset was locked
+     * The type of the loop detected:
+     * - Soft - the playback will immediately jump to the loop start pointer without any further processing.
+     * - Hard - the playback will quickly process all messages from
+     * the start of the file to ensure that synthesizer is in the correct state.
+     * This is the default behavior.
+     *
+     * Soft loop types are enabled for Touhou and GameMaker loop points.
      */
-    lockedSystem: SynthSystem;
+    type: MIDILoopType;
+}
+type MIDIFormat = 0 | 1 | 2;
+interface NoteTime {
     /**
-     * The array of all MIDI controllers (in 14-bit values) with the modulator sources at the end.
+     * The MIDI key number.
      */
-    midiControllers: Int16Array;
+    midiNote: number;
     /**
-     * An array of booleans, indicating if the controller with a current index is locked.
+     * Start of the note, in seconds.
      */
-    lockedControllers: boolean[];
+    start: number;
     /**
-     * Array of custom (not SF2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
+     * Length of the note, in seconds.
      */
-    customControllers: Float32Array;
+    length: number;
     /**
-     * Indicates whether the channel vibrato is locked.
+     * The MIDI velocity of the note.
      */
-    lockVibrato: boolean;
+    velocity: number;
+}
+/**
+ * Represents a desired program change for a MIDI channel.
+ */
+interface DesiredProgramChange extends MIDIPatch {
     /**
-     * The channel's vibrato settings.
-     * @property depth Vibrato depth, in gain.
-     * @property delay Vibrato delay from note on in seconds.
-     * @property rate Vibrato rate in Hz.
+     * The channel number.
      */
-    channelVibrato: {
-        depth: number;
-        delay: number;
-        rate: number;
-    };
+    channel: number;
+}
+/**
+ * Represents a desired controller change for a MIDI channel.
+ */
+interface DesiredControllerChange {
     /**
-     * Key shift for the channel.
+     * The channel number.
      */
-    channelTransposeKeyShift: number;
+    channel: number;
     /**
-     * The channel's octave tuning in cents.
+     * The MIDI controller number.
      */
-    channelOctaveTuning: Int8Array;
+    controllerNumber: number;
     /**
-     * Indicates whether the channel is muted.
+     * The new controller value.
      */
-    isMuted: boolean;
+    controllerValue: number;
+}
+/**
+ * Represents a desired channel transpose change.
+ */
+interface DesiredChannelTranspose {
     /**
-     * Indicates whether the channel is a drum channel.
+     * The channel number.
+     */
+    channel: number;
+    /**
+     * The number of semitones to transpose.
+     * This can use floating point numbers, which will be used to fine-tune the pitch in cents using RPN.
      */
-    drumChannel: boolean;
+    keyShift: number;
+}
+interface RMIDIWriteOptions {
     /**
-     * The channel number this snapshot represents.
+     * The bank offset for RMIDI.
      */
-    channelNumber: number;
-    constructor(patch: MIDIPatchNamed, lockPreset: boolean, lockedSystem: SynthSystem, midiControllers: Int16Array, lockedControllers: boolean[], customControllers: Float32Array, lockVibrato: boolean, channelVibrato: {
-        delay: number;
-        depth: number;
-        rate: number;
-    }, channelTransposeKeyShift: number, channelOctaveTuning: Int8Array, isMuted: boolean, drumChannel: boolean, channelNumber: number);
+    bankOffset: number;
     /**
-     * Creates a copy of existing snapshot.
-     * @param snapshot The snapshot to create a copy from.
+     * The metadata of the file. Optional.
      */
-    static copyFrom(snapshot: ChannelSnapshot): ChannelSnapshot;
+    metadata: Partial<Omit<RMIDInfoData, "infoEncoding">>;
     /**
-     * Creates a snapshot of the channel's state.
-     * @param spessaSynthProcessor The synthesizer processor containing the channel.
-     * @param channelNumber The channel number to snapshot.
+     * If the MIDI file should internally be corrected to work with the set bank offset.
      */
-    static create(spessaSynthProcessor: SpessaSynthProcessor, channelNumber: number): ChannelSnapshot;
+    correctBankOffset: boolean;
     /**
-     * Applies the snapshot to the specified channel.
-     * @param spessaSynthProcessor The processor containing the channel.
+     * The optional sound bank instance used to correct bank offset.
      */
-    apply(spessaSynthProcessor: SpessaSynthProcessor): void;
+    soundBank?: BasicSoundBank;
 }
+type RMIDInfoFourCC = "INAM" | "IPRD" | "IALB" | "IART" | "IGNR" | "IPIC" | "ICOP" | "ICRD" | "ICRT" | "ICMT" | "IENG" | "ISFT" | "ISBJ" | "IENC" | "MENC" | "DBNK";
 
 /**
  * A manager for custom key overrides for channels
@@ -1998,1057 +2220,1055 @@ declare class KeyModifierManager {
     getPatch(channel: number, midiNote: number): MIDIPatch;
 }
 
-/**
- * Represents a snapshot of the synthesizer's state.
- */
-declare class SynthesizerSnapshot {
-    /**
-     * The individual channel snapshots.
-     */
-    channelSnapshots: ChannelSnapshot[];
-    /**
-     * Key modifiers.
-     */
-    keyMappings: (KeyModifier | undefined)[][];
-    masterParameters: MasterParameterType;
-    constructor(channelSnapshots: ChannelSnapshot[], masterParameters: MasterParameterType, keyMappings: (KeyModifier | undefined)[][]);
-    /**
-     * Creates a new synthesizer snapshot from the given SpessaSynthProcessor.
-     * @param processor the processor to take a snapshot of.
-     * @returns The snapshot.
-     */
-    static create(processor: SpessaSynthProcessor): SynthesizerSnapshot;
-    /**
-     * Creates a copy of existing snapshot.
-     * @param snapshot The snapshot to create a copy from.
-     */
-    static copyFrom(snapshot: SynthesizerSnapshot): SynthesizerSnapshot;
-    /**
-     * Applies the snapshot to the synthesizer.
-     * @param processor the processor to apply the snapshot to.
-     */
-    apply(processor: SpessaSynthProcessor): void;
-}
-
-/**
- * Processor.ts
- * purpose: the core synthesis engine
- */
-declare class SpessaSynthProcessor {
-    soundBankManager: SoundBankManager;
-    /**
-     * All MIDI channels of the synthesizer.
-     */
-    midiChannels: MIDIChannel[];
-    /**
-     * Handles the custom key overrides: velocity and preset
-     */
-    keyModifierManager: KeyModifierManager;
-    /**
-     * Current total amount of voices that are currently playing.
-     */
-    totalVoicesAmount: number;
-    /**
-     * Controls if the processor is fully initialized.
-     */
-    readonly processorInitialized: Promise<boolean>;
-    /**
-     * The current time of the synthesizer, in seconds. You probably should not modify this directly.
-     */
-    currentSynthTime: number;
-    /**
-     * Sample rate in Hertz.
-     */
-    readonly sampleRate: number;
-    /**
-     * Are the chorus and reverb effects enabled?
-     */
-    enableEffects: boolean;
-    /**
-     * Is the event system enabled?
-     */
-    enableEventSystem: boolean;
-    /**
-     * Calls when an event occurs.
-     * @param event The event that occurred.
-     */
-    onEventCall?: (event: SynthProcessorEvent) => unknown;
-    /**
-     * Executes a system exclusive message for the synthesizer.
-     * @param syx The system exclusive message as an array of bytes.
-     * @param channelOffset The channel offset to apply (default is 0).
-     */
-    readonly systemExclusive: typeof systemExclusiveInternal;
-    /**
-     * Executes a full system reset of all controllers.
-     * This will reset all controllers to their default values,
-     * except for the locked controllers.
-     */
-    readonly resetAllControllers: typeof resetAllControllersInternal;
-    /**
-     * Sets a master parameter of the synthesizer.
-     * @param type The type of the master parameter to set.
-     * @param value The value to set for the master parameter.
-     */
-    readonly setMasterParameter: typeof setMasterParameterInternal;
-    /**
-     * Gets a master parameter of the synthesizer.
-     * @param type The type of the master parameter to get.
-     * @returns The value of the master parameter.
-     */
-    readonly getMasterParameter: typeof getMasterParameterInternal;
-    /**
-     * Gets all master parameters of the synthesizer.
-     * @returns All the master parameters.
-     */
-    readonly getAllMasterParameters: typeof getAllMasterParametersInternal;
-    /**
-     * Gets voices for a preset.
-     * @param preset The preset to get voices for.
-     * @param bankMSB The bank to cache the voices in.
-     * @param program Program to cache the voices in.
-     * @param midiNote The MIDI note to use.
-     * @param velocity The velocity to use.
-     * @param realKey The real MIDI note if the "midiNote" was changed by MIDI Tuning Standard.
-     * @returns Output is an array of voices.
-     * @remarks
-     * This is a public method, but it is only intended to be used by the sequencer.
-     */
-    readonly getVoicesForPreset: typeof getVoicesForPresetInternal;
-    /**
-     * Kills the specified number of voices based on their priority.
-     * @param amount The number of voices to remove.
-     */
-    readonly killVoices: typeof killVoicesIntenral;
-    protected readonly getVoices: (channel: number, midiNote: number, velocity: number, realKey: number) => VoiceList;
-    protected privateProps: ProtectedSynthValues;
-    /**
-     * Tor applying the snapshot after an override sound bank too.
-     */
-    protected savedSnapshot?: SynthesizerSnapshot;
-    /**
-     * Synth's event queue from the main thread
-     */
-    protected eventQueue: {
-        callback: () => unknown;
-        time: number;
-    }[];
-    private readonly sampleTime;
-    /**
-     * Creates a new synthesizer engine.
-     * @param sampleRate sample rate, in Hertz.
-     * @param opts the processor's options.
-     */
-    constructor(sampleRate: number, opts?: Partial<SynthProcessorOptions>);
-    /**
-     * Applies the snapshot to the synth
-     */
-    applySynthesizerSnapshot(snapshot: SynthesizerSnapshot): void;
-    /**
-     * Gets a synthesizer snapshot from this processor instance.
-     */
-    getSnapshot(): SynthesizerSnapshot;
-    /**
-     * Sets the embedded sound bank.
-     * @param bank The sound bank file to set.
-     * @param offset The bank offset of the embedded sound bank.
-     */
-    setEmbeddedSoundBank(bank: ArrayBuffer, offset: number): void;
-    clearEmbeddedBank(): void;
-    createMIDIChannel(): void;
+declare class SoundBankManager {
     /**
-     * Stops all notes on all channels.
-     * @param force if true, all notes are stopped immediately, otherwise they are stopped gracefully.
+     * All the sound banks, ordered from the most important to the least.
      */
-    stopAllChannels(force?: boolean): void;
+    soundBankList: SoundBankManagerListEntry[];
+    private readonly presetListChangeCallback;
+    private selectablePresetList;
     /**
-     * Renders float32 audio data to stereo outputs; buffer size of 128 is recommended.
-     * All float arrays must have the same length.
-     * @param outputs output stereo channels (L, R).
-     * @param reverb reverb stereo channels (L, R).
-     * @param chorus chorus stereo channels (L, R).
-     * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
-     * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
+     * @param presetListChangeCallback Supplied by the parent synthesizer class,
+     * this is called whenever the preset list changes.
      */
-    renderAudio(outputs: Float32Array[], reverb: Float32Array[], chorus: Float32Array[], startIndex?: number, sampleCount?: number): void;
+    constructor(presetListChangeCallback: () => unknown);
+    private _presetList;
     /**
-     * Renders the float32 audio data of each channel; buffer size of 128 is recommended.
-     * All float arrays must have the same length.
-     * @param reverbChannels reverb stereo channels (L, R).
-     * @param chorusChannels chorus stereo channels (L, R).
-     * @param separateChannels a total of 16 stereo pairs (L, R) for each MIDI channel.
-     * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
-     * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
+     * The list of all presets in the sound bank stack.
      */
-    renderAudioSplit(reverbChannels: Float32Array[], chorusChannels: Float32Array[], separateChannels: Float32Array[][], startIndex?: number, sampleCount?: number): void;
+    get presetList(): PresetListEntry[];
     /**
-     *  Destroy the synthesizer processor, clearing all channels and voices.
-     *  This is irreversible, so use with caution.
+     * The current sound bank priority order.
+     * @returns The IDs of the sound banks in the current order.
      */
-    destroySynthProcessor(): void;
+    get priorityOrder(): string[];
     /**
-     * Executes a MIDI controller change message on the specified channel.
-     * @param channel The MIDI channel to change the controller on.
-     * @param controllerNumber The MIDI controller number to change.
-     * @param controllerValue The value to set the controller to.
+     * The current sound bank priority order.
+     * @param newList The new order of sound bank IDs.
      */
-    controllerChange(channel: number, controllerNumber: MIDIController, controllerValue: number): void;
+    set priorityOrder(newList: string[]);
     /**
-     * Executes a MIDI Note-on message on the specified channel.
-     * @param channel The MIDI channel to send the note on.
-     * @param midiNote The MIDI note number to play.
-     * @param velocity The velocity of the note, from 0 to 127.
-     * @remarks
-     * If the velocity is 0, it will be treated as a Note-off message.
+     * Deletes a given sound bank by its ID.
+     * @param id the ID of the sound bank to delete.
      */
-    noteOn(channel: number, midiNote: number, velocity: number): void;
+    deleteSoundBank(id: string): void;
     /**
-     * Executes a MIDI Note-off message on the specified channel.
-     * @param channel The MIDI channel to send the note off.
-     * @param midiNote The MIDI note number to stop playing.
+     * Adds a new sound bank with a given ID, or replaces an existing one.
+     * @param font the sound bank to add.
+     * @param id the ID of the sound bank.
+     * @param bankOffset the bank offset of the sound bank.
      */
-    noteOff(channel: number, midiNote: number): void;
+    addSoundBank(font: BasicSoundBank, id: string, bankOffset?: number): void;
     /**
-     * Executes a MIDI Poly Pressure (Aftertouch) message on the specified channel.
-     * @param channel The MIDI channel to send the poly pressure on.
-     * @param midiNote The MIDI note number to apply the pressure to.
-     * @param pressure The pressure value, from 0 to 127.
+     * Gets a given preset from the sound bank stack.
+     * @param patch The MIDI patch to search for.
+     * @param system The MIDI system to select the preset for.
+     * @returns An object containing the preset and its bank offset.
      */
-    polyPressure(channel: number, midiNote: number, pressure: number): void;
+    getPreset(patch: MIDIPatch, system: SynthSystem): BasicPreset | undefined;
+    destroy(): void;
+    private generatePresetList;
+}
+
+/**
+ * Reset all controllers for channel.
+ * This will reset all controllers to their default values,
+ * except for the locked controllers.
+ */
+declare function resetControllers(this: MIDIChannel, sendCCEvents?: boolean): void;
+declare function resetPreset(this: MIDIChannel): void;
+/**
+ * https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
+ * Reset controllers according to RP-15 Recommended Practice.
+ */
+declare function resetControllersRP15Compliant(this: MIDIChannel): void;
+/**
+ * Reset all parameters to their default values.
+ * This includes NRPN and RPN controllers, data entry state,
+ * and generator overrides and offsets.
+ */
+declare function resetParameters(this: MIDIChannel): void;
+
+/**
+ * Executes a data entry fine (LSB) change for the current channel.
+ * @param dataValue The value to set for the data entry fine controller (0-127).
+ */
+declare function dataEntryFine(this: MIDIChannel, dataValue: number): void;
+
+/**
+ * Handles MIDI controller changes for a channel.
+ * @param controllerNumber The MIDI controller number (0-127).
+ * @param controllerValue The value of the controller (0-127).
+ * @param sendEvent If an event should be emitted.
+ * @remarks
+ * This function processes MIDI controller changes, updating the channel's
+ * midiControllers table and handling special cases like bank select,
+ * data entry, and sustain pedal. It also computes modulators for all voices
+ * in the channel based on the controller change.
+ * If the controller number is greater than 127, it is treated as a channel
+ * configuration controller, and the `force` parameter must be set to true
+ * to allow changes.
+ */
+declare function controllerChange(this: MIDIChannel, controllerNumber: MIDIController, controllerValue: number, sendEvent?: boolean): void;
+
+/**
+ * Executes a data entry coarse (MSB) change for the current channel.
+ * @param dataValue The value to set for the data entry coarse controller (0-127).
+ */
+declare function dataEntryCoarse(this: MIDIChannel, dataValue: number): void;
+
+/**
+ * Sends a "MIDI Note on" message and starts a note.
+ * @param midiNote The MIDI note number (0-127).
+ * @param velocity The velocity of the note (0-127). If less than 1, it will send a note off instead.
+ */
+declare function noteOn(this: MIDIChannel, midiNote: number, velocity: number): void;
+
+/**
+ * Releases a note by its MIDI note number.
+ * If the note is in high performance mode and the channel is not a drum channel,
+ * it kills the note instead of releasing it.
+ * @param midiNote The MIDI note number to release (0-127).
+ */
+declare function noteOff(this: MIDIChannel, midiNote: number): void;
+
+/**
+ * Changes the program (preset) of the channel.
+ * @param program The program number (0-127) to change to.
+ */
+declare function programChange(this: MIDIChannel, program: number): void;
+
+/**
+ * A class for dynamic modulators
+ * that are assigned for more complex system exclusive messages
+ */
+declare class DynamicModulatorSystem {
     /**
-     * Executes a MIDI Channel Pressure (Aftertouch) message on the specified channel.
-     * @param channel The MIDI channel to send the channel pressure on.
-     * @param pressure The pressure value, from 0 to 127.
+     * The current dynamic modulator list.
      */
-    channelPressure(channel: number, pressure: number): void;
+    modulatorList: {
+        mod: Modulator;
+        id: string;
+    }[];
+    resetModulators(): void;
     /**
-     * Executes a MIDI Pitch Wheel message on the specified channel.
-     * @param channel The MIDI channel to send the pitch wheel on.
-     * @param pitch The new pitch value: 0-16384
+     * @param source Like in midiControllers: values below NON_CC_INDEX_OFFSET are CCs,
+     * above are regular modulator sources.
+     * @param destination The generator type to modulate.
+     * @param amount The amount of modulation to apply.
+     * @param isBipolar If true, the modulation is bipolar (ranges from -1 to 1 instead of from 0 to 1).
+     * @param isNegative If true, the modulation is negative (goes from 1 to 0 instead of from 0 to 1).
      */
-    pitchWheel(channel: number, pitch: number): void;
+    setModulator(source: ModulatorSourceEnum, destination: GeneratorType, amount: number, isBipolar?: boolean, isNegative?: boolean): void;
+    private getModulatorID;
+    private deleteModulator;
+}
+
+/**
+ * Sets a master parameter of the synthesizer.
+ * @param parameter The type of the master parameter to set.
+ * @param value The value to set for the master parameter.
+ */
+declare function setMasterParameterInternal<P extends keyof MasterParameterType>(this: SynthesizerCore, parameter: P, value: MasterParameterType[P]): void;
+/**
+ * Gets a master parameter of the synthesizer.
+ * @param type The type of the master parameter to get.
+ * @returns The value of the master parameter.
+ */
+declare function getMasterParameterInternal<P extends keyof MasterParameterType>(this: SynthesizerCore, type: P): MasterParameterType[P];
+/**
+ * Gets all master parameters of the synthesizer.
+ * @returns All the master parameters.
+ */
+declare function getAllMasterParametersInternal(this: SynthesizerCore): MasterParameterType;
+
+type SysExAcceptedArray = number[] | IndexedByteArray | Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Uint8ClampedArray | Float32Array | Float64Array;
+
+/**
+ * Executes a system exclusive message for the synthesizer.
+ * @param syx The system exclusive message as an array of bytes.
+ * @param channelOffset The channel offset to apply (default is 0).
+ * @remarks
+ * This is a rather extensive method that handles various system exclusive messages,
+ * including Roland GS, MIDI Tuning Standard, and other non-realtime messages.
+ */
+declare function systemExclusiveInternal(this: SynthesizerCore, syx: SysExAcceptedArray, channelOffset: number): void;
+
+/**
+ * The core synthesis engine which interacts with channels and holds all the synth parameters.
+ */
+declare class SynthesizerCore {
     /**
-     * Executes a MIDI Program Change message on the specified channel.
-     * @param channel The MIDI channel to send the program change on.
-     * @param programNumber The program number to change to, from 0 to 127.
+     * Voices of this synthesizer, as a fixed voice pool.
      */
-    programChange(channel: number, programNumber: number): void;
+    readonly voices: Voice[];
     /**
-     * Processes a raw MIDI message.
-     * @param message The message to process.
-     * @param channelOffset The channel offset for the message.
-     * @param force If true, forces the message to be processed.
-     * @param options Additional options for scheduling the message.
+     * All MIDI channels of the synthesizer.
      */
-    processMessage(message: Uint8Array | number[], channelOffset?: number, force?: boolean, options?: SynthMethodOptions): void;
-    clearCache(): void;
+    midiChannels: MIDIChannel[];
     /**
-     * @param volume {number} 0 to 1
+     * The sound bank manager, which manages all sound banks and presets.
      */
-    protected setMIDIVolume(volume: number): void;
+    soundBankManager: SoundBankManager;
     /**
-     * Sets the synth's primary tuning.
-     * @param cents
+     * Handles the custom key overrides: velocity and preset
      */
-    protected setMasterTuning(cents: number): void;
+    keyModifierManager: KeyModifierManager;
+    readonly sampleRate: number;
     /**
-     * Calls synth event
-     * @param eventName the event name
-     * @param eventData the event data
+     * This.tunings[program * 128 + key] = midiNote,cents (fraction)
+     * All MIDI Tuning Standard tunings, 128 keys for each of 128 programs.
+     * -1 means no change.
      */
-    protected callEvent<K extends keyof SynthProcessorEventData>(eventName: K, eventData: SynthProcessorEventData[K]): void;
-    protected getCachedVoice(patch: MIDIPatch, midiNote: number, velocity: number): VoiceList | undefined;
-    protected setCachedVoice(patch: MIDIPatch, midiNote: number, velocity: number, voices: VoiceList): void;
-    private getCachedVoiceIndex;
-    private createMIDIChannelInternal;
-    private updatePresetList;
-    private getDefaultPresets;
-}
-
-declare class LowpassFilter {
+    readonly tunings: Float32Array<ArrayBuffer>;
     /**
-     * Cached coefficient calculations.
-     * stored as cachedCoefficients[resonanceCb][currentInitialFc].
+     * The master parameters of the synthesizer.
      */
-    private static cachedCoefficients;
+    masterParameters: MasterParameterType;
     /**
-     * Resonance in centibels.
+     * The current time of the synthesizer, in seconds.
      */
-    resonanceCb: number;
+    currentTime: number;
     /**
-     * Current cutoff frequency in absolute cents.
+     * The volume gain, set by MIDI sysEx
      */
-    currentInitialFc: number;
+    midiVolume: number;
     /**
-     * Filter coefficient 1.
+     * Set via system exclusive.
+     * Note: Remember to reset in system reset!
      */
-    private a0;
+    reverbSend: number;
     /**
-     * Filter coefficient 2.
+     * Are the chorus and reverb effects enabled?
      */
-    private a1;
+    enableEffects: boolean;
     /**
-     * Filter coefficient 3.
+     * Is the event system enabled?
      */
-    private a2;
+    enableEventSystem: boolean;
     /**
-     * Filter coefficient 4.
+     * Set via system exclusive.
+     * Note: Remember to reset in system reset!
      */
-    private a3;
+    chorusSend: number;
     /**
-     * Filter coefficient 5.
+     * The pan of the left channel.
      */
-    private a4;
+    panLeft: number;
     /**
-     * Input history 1.
+     * The pan of the right channel.
      */
-    private x1;
+    panRight: number;
     /**
-     * Input history 2.
+     * Synth's default (reset) preset.
      */
-    private x2;
+    defaultPreset: BasicPreset | undefined;
     /**
-     * Output history 1.
+     * Synth's default (reset) drum preset.
      */
-    private y1;
+    drumPreset: BasicPreset | undefined;
     /**
-     * Output history 2.
+     * Gain smoothing factor, adjusted to the sample rate.
      */
-    private y2;
+    readonly gainSmoothingFactor: number;
     /**
-     * For tracking the last cutoff frequency in the apply method, absolute cents.
-     * Set to infinity to force recalculation.
+     * Pan smoothing factor, adjusted to the sample rate.
      */
-    private lastTargetCutoff;
+    readonly panSmoothingFactor: number;
     /**
-     * Used for tracking if the filter has been initialized.
+     * Calls when an event occurs.
+     * @param eventType The event type.
+     * @param eventData The event data.
      */
-    private initialized;
+    eventCallbackHandler: <K extends keyof SynthProcessorEventData>(eventType: K, eventData: SynthProcessorEventData[K]) => unknown;
+    readonly missingPresetHandler: (patch: MIDIPatch, system: SynthSystem) => undefined | BasicPreset;
     /**
-     * Filter's sample rate in Hz.
+     * Cached voices for all presets for this synthesizer.
+     * Nesting is calculated in getCachedVoiceIndex, returns a list of voices for this note.
      */
-    private sampleRate;
+    readonly cachedVoices: Map<number, CachedVoiceList>;
     /**
-     * Maximum cutoff frequency in Hz.
-     * This is used to prevent aliasing and ensure the filter operates within the valid frequency range.
+     * Sets a master parameter of the synthesizer.
+     * @param type The type of the master parameter to set.
+     * @param value The value to set for the master parameter.
      */
-    private maxCutoff;
+    readonly setMasterParameter: typeof setMasterParameterInternal;
     /**
-     * Initializes a new instance of the filter.
-     * @param sampleRate the sample rate of the audio engine in Hz.
+     * Gets a master parameter of the synthesizer.
+     * @param type The type of the master parameter to get.
+     * @returns The value of the master parameter.
      */
-    constructor(sampleRate: number);
+    readonly getMasterParameter: typeof getMasterParameterInternal;
     /**
-     * Applies the lowpass filter to the output buffer of a voice.
-     * @param voice The voice to apply the filter to.
-     * @param outputBuffer The output buffer to filter.
-     * @param fcExcursion The frequency excursion in cents to apply to the filter.
-     * @param smoothingFactor The smoothing factor for the filter as determined by the parent synthesizer.
+     * Gets all master parameters of the synthesizer.
+     * @returns All the master parameters.
      */
-    static apply(voice: Voice, outputBuffer: Float32Array, fcExcursion: number, smoothingFactor: number): void;
+    readonly getAllMasterParameters: typeof getAllMasterParametersInternal;
+    readonly systemExclusive: typeof systemExclusiveInternal;
     /**
-     * Calculates the filter coefficients based on the current resonance and cutoff frequency and caches them.
-     * @param filter The lowpass filter instance to calculate coefficients for.
-     * @param cutoffCents The cutoff frequency in cents.
+     * Current total amount of voices that are currently playing.
      */
-    static calculateCoefficients(filter: LowpassFilter, cutoffCents: number): void;
-}
-
-/**
- * VOL ENV STATES:
- * 0 - delay
- * 1 - attack
- * 2 - hold/peak
- * 3 - decay
- * 4 - sustain
- * release indicates by isInRelease property
- */
-type VolumeEnvelopeState = 0 | 1 | 2 | 3 | 4;
-declare class VolumeEnvelope {
+    voiceCount: number;
     /**
-     * The sample rate in Hz.
+     * Last time the priorities were assigned.
+     * Used to prevent assigning priorities multiple times when more than one voice is triggered during a quantum.
      */
-    sampleRate: number;
+    private lastPriorityAssignmentTime;
     /**
-     * The current attenuation of the envelope in dB.
+     * Synth's event queue from the main thread
      */
-    currentAttenuationDb: number;
+    private eventQueue;
     /**
-     * The current stage of the volume envelope.
+     * The time of a single sample, in seconds.
      */
-    state: VolumeEnvelopeState;
+    private readonly sampleTime;
+    constructor(eventCallbackHandler: <K extends keyof SynthProcessorEventData>(eventType: K, eventData: SynthProcessorEventData[K]) => unknown, missingPresetHandler: (patch: MIDIPatch, system: SynthSystem) => BasicPreset | undefined, sampleRate: number, options: SynthProcessorOptions);
     /**
-     * The voice's absolute attenuation as linear gain.
+     * Assigns the first available voice for use.
+     * If none available, will assign priorities.
      */
-    attenuation: number;
+    assignVoice(): Voice;
     /**
-     * The attenuation target, which the "attenuation" property is linearly interpolated towards (gain).
+     * Stops all notes on all channels.
+     * @param force if true, all notes are stopped immediately, otherwise they are stopped gracefully.
      */
-    attenuationTargetGain: number;
+    stopAllChannels(force: boolean): void;
     /**
-     * The envelope's current time in samples.
+     * Processes a raw MIDI message.
+     * @param message The message to process.
+     * @param channelOffset The channel offset for the message.
+     * @param force If true, forces the message to be processed.
+     * @param options Additional options for scheduling the message.
      */
-    protected currentSampleTime: number;
+    processMessage(message: Uint8Array | number[], channelOffset: number, force: boolean, options: SynthMethodOptions): void;
+    destroySynthProcessor(): void;
     /**
-     * The dB attenuation of the envelope when it entered the release stage.
+     * @param channel channel to get voices for
+     * @param midiNote the MIDI note to use
+     * @param velocity the velocity to use
+     * @returns output is an array of Voices
      */
-    protected releaseStartDb: number;
+    getVoices(channel: number, midiNote: number, velocity: number): CachedVoiceList;
+    createMIDIChannel(sendEvent: boolean): void;
     /**
-     * The time in samples relative to the start of the envelope.
+     * Executes a full system reset of all controllers.
+     * This will reset all controllers to their default values,
+     * except for the locked controllers.
      */
-    protected releaseStartTimeSamples: number;
+    resetAllControllers(system?: SynthSystem): void;
+    renderAudio(outputs: Float32Array[], reverb: Float32Array[], chorus: Float32Array[], startIndex?: number, sampleCount?: number): void;
     /**
-     * The current gain applied to the voice in the release stage.
+     * Renders the float32 audio data of each channel; buffer size of 128 is recommended.
+     * All float arrays must have the same length.
+     * @param reverb reverb stereo channels (L, R).
+     * @param chorus chorus stereo channels (L, R).
+     * @param separate a total of 16 stereo pairs (L, R) for each MIDI channel.
+     * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
+     * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
      */
-    protected currentReleaseGain: number;
+    renderAudioSplit(reverb: Float32Array[], chorus: Float32Array[], separate: Float32Array[][], startIndex?: number, sampleCount?: number): void;
     /**
-     * The attack duration in samples.
+     * Gets voices for a preset.
+     * @param preset The preset to get voices for.
+     * @param midiNote The MIDI note to use.
+     * @param velocity The velocity to use.
+     * @returns Output is an array of voices.
      */
-    protected attackDuration: number;
+    getVoicesForPreset(preset: BasicPreset, midiNote: number, velocity: number): CachedVoiceList;
+    clearCache(): void;
     /**
-     * The decay duration in samples.
+     * Copied callback so MIDI channels can call it.
      */
-    protected decayDuration: number;
+    callEvent<K extends keyof SynthProcessorEventData>(eventName: K, eventData: SynthProcessorEventData[K]): void;
     /**
-     * The release duration in samples.
+     * @param volume {number} 0 to 1
      */
-    protected releaseDuration: number;
+    protected setMIDIVolume(volume: number): void;
     /**
-     * The attenuation target, which the "attenuation" property is linearly interpolated towards (dB).
+     * Sets the synth's primary tuning.
+     * @param cents
      */
-    protected attenuationTarget: number;
+    protected setMasterTuning(cents: number): void;
+    protected getCachedVoice(patch: MIDIPatch, midiNote: number, velocity: number): CachedVoiceList | undefined;
+    protected setCachedVoice(patch: MIDIPatch, midiNote: number, velocity: number, voices: CachedVoiceList): void;
     /**
-     * The voice's sustain amount in dB, relative to attenuation.
+     * Assigns priorities to the voices.
+     * Gets the priority of a voice based on its channel and state.
+     * Higher priority means the voice is more important and should be kept longer.
      */
-    protected sustainDbRelative: number;
+    private assignVoicePriorities;
+    private updatePresetList;
+    private getDefaultPresets;
+    private getCachedVoiceIndex;
+}
+
+/**
+ * This class represents a single MIDI Channel within the synthesizer.
+ */
+declare class MIDIChannel {
+    readonly midiControllers: Int16Array;
     /**
-     * The time in samples to the end of delay stage, relative to the start of the envelope.
+     * An array for the MIDI 2.0 Per-note pitch wheels.
      */
-    protected delayEnd: number;
+    readonly pitchWheels: Int16Array<ArrayBuffer>;
     /**
-     * The time in samples to the end of attack stage, relative to the start of the envelope.
+     * An array indicating if a controller, at the equivalent index in the midiControllers array, is locked
+     * (i.e., not allowed changing).
+     * A locked controller cannot be modified.
      */
-    protected attackEnd: number;
+    lockedControllers: boolean[];
     /**
-     * The time in samples to the end of hold stage, relative to the start of the envelope.
+     * An array of custom (non-SF2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
+     * Refer to controller_tables.ts for the index definitions.
      */
-    protected holdEnd: number;
+    readonly customControllers: Float32Array;
     /**
-     * The time in samples to the end of decay stage, relative to the start of the envelope.
+     * The key shift of the channel (in semitones).
      */
-    protected decayEnd: number;
+    channelTransposeKeyShift: number;
     /**
-     * If sustain stage is silent,
-     * then we can turn off the voice when it is silent.
-     * We can't do that with modulated as it can silence the volume and then raise it again, and the voice must keep playing.
+     * An array of octave tuning values for each note on the channel.
+     * Each index corresponds to a note (0 = C, 1 = C#, ..., 11 = B).
+     * Note: Repeated every 12 notes.
      */
-    protected canEndOnSilentSustain: boolean;
+    channelOctaveTuning: Int8Array;
     /**
-     * @param sampleRate Hz
-     * @param initialDecay cb
+     * A system for dynamic modulator assignment for advanced system exclusives.
      */
-    constructor(sampleRate: number, initialDecay: number);
+    sysExModulators: DynamicModulatorSystem;
     /**
-     * Starts the release phase in the envelope.
-     * @param voice the voice this envelope belongs to.
+     * Indicates whether this channel is a drum channel.
      */
-    static startRelease(voice: Voice): void;
+    drumChannel: boolean;
     /**
-     * Recalculates the envelope
-     * @param voice the voice this envelope belongs to
+     * Enables random panning for every note played on this channel.
      */
-    static recalculate(voice: Voice): void;
+    randomPan: boolean;
     /**
-     * Applies volume envelope gain to the given output buffer.
-     * Essentially we use approach of 100dB is silence, 0dB is peak, and always add attenuation to that (which is interpolated).
-     * @param voice the voice we're working on
-     * @param audioBuffer the audio buffer to modify
-     * @param centibelOffset the centibel offset of volume, for modLFOtoVolume
-     * @param smoothingFactor the adjusted smoothing factor for the envelope
+     * The current state of the data entry for the channel.
      */
-    static apply(voice: Voice, audioBuffer: Float32Array, centibelOffset: number, smoothingFactor: number): void;
-}
-
-declare class ModulationEnvelope {
+    dataEntryState: DataEntryState;
     /**
-     * The attack duration, in seconds.
+     * The currently selected MIDI patch of the channel.
+     * Note that the exact matching preset may not be available, but this represents exactly what MIDI asks for.
      */
-    protected attackDuration: number;
+    readonly patch: MIDIPatch;
     /**
-     * The decay duration, in seconds.
+     * The preset currently assigned to the channel.
+     * Note that this may be undefined in some cases
+     * https://github.com/spessasus/spessasynth_core/issues/48
      */
-    protected decayDuration: number;
+    preset?: BasicPreset;
     /**
-     * The hold duration, in seconds.
+     * Indicates whether the program on this channel is locked.
      */
-    protected holdDuration: number;
+    lockPreset: boolean;
     /**
-     * Release duration, in seconds.
+     * Indicates the MIDI system when the preset was locked.
      */
-    protected releaseDuration: number;
+    lockedSystem: SynthSystem;
     /**
-     * The sustain level 0-1.
+     * Indicates whether the GS NRPN parameters are enabled for this channel.
      */
-    protected sustainLevel: number;
+    lockGSNRPNParams: boolean;
     /**
-     * Delay phase end time in seconds, absolute (audio context time).
+     * The vibrato settings for the channel.
+     * @property depth - Depth of the vibrato effect in cents.
+     * @property delay - Delay before the vibrato effect starts (in seconds).
+     * @property rate - Rate of the vibrato oscillation (in Hz).
      */
-    protected delayEnd: number;
+    channelVibrato: {
+        delay: number;
+        depth: number;
+        rate: number;
+    };
     /**
-     * Attack phase end time in seconds, absolute (audio context time).
+     * If the channel is in the poly mode.
+     * True - POLY ON - regular playback.
+     * False - MONO ON - one note per channel, others are killed on note-on
      */
-    protected attackEnd: number;
+    polyMode: boolean;
     /**
-     * Hold phase end time in seconds, absolute (audio context time).
+     * Channel's current voice count
      */
-    protected holdEnd: number;
+    voiceCount: number;
     /**
-     * Decay phase end time in seconds, absolute (audio context time).
+     * The channel's number (0-based index)
      */
-    protected decayEnd: number;
+    readonly channel: number;
     /**
-     * The level of the envelope when the release phase starts.
+     * Core synthesis engine.
      */
-    protected releaseStartLevel: number;
+    synthCore: SynthesizerCore;
     /**
-     * The current modulation envelope value.
+     * Sends a "MIDI Note on" message and starts a note.
+     * @param midiNote The MIDI note number (0-127).
+     * @param velocity The velocity of the note (0-127). If less than 1, it will send a note off instead.
      */
-    protected currentValue: number;
+    noteOn: typeof noteOn;
     /**
-     * Starts the release phase in the envelope.
-     * @param voice the voice this envelope belongs to.
+     * Releases a note by its MIDI note number.
+     * If the note is in high performance mode and the channel is not a drum channel,
+     * it kills the note instead of releasing it.
+     * @param midiNote The MIDI note number to release (0-127).
      */
-    static startRelease(voice: Voice): void;
+    noteOff: typeof noteOff;
     /**
-     * @param voice the voice to recalculate.
+     * Changes the program (preset) of the channel.
+     * @param programNumber The program number (0-127) to change to.
      */
-    static recalculate(voice: Voice): void;
+    programChange: typeof programChange;
+    controllerChange: typeof controllerChange;
     /**
-     * Calculates the current modulation envelope value for the given time and voice.
-     * @param voice the voice we are working on.
-     * @param currentTime in seconds.
-     * @param ignoreRelease if true, it will compute the value as if the voice was not released.
-     * @returns  mod env value, from 0 to 1.
+     * Reset all controllers for channel.
+     * This will reset all controllers to their default values,
+     * except for the locked controllers.
      */
-    static getValue(voice: Voice, currentTime: number, ignoreRelease?: boolean): number;
-}
-
-declare class AudioSample {
+    readonly resetControllers: typeof resetControllers;
+    readonly resetPreset: typeof resetPreset;
     /**
-     * The sample's audio data
+     * https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
+     * Reset controllers according to RP-15 Recommended Practice.
      */
-    readonly sampleData: Float32Array;
+    readonly resetControllersRP15Compliant: typeof resetControllersRP15Compliant;
     /**
-     * Current playback step (rate)
+     * Reset all parameters to their default values.
+     * This includes NRPN and RPN controllers, data entry state,
+     * and generator overrides and offsets.
      */
-    readonly playbackStep: number;
+    resetParameters: typeof resetParameters;
     /**
-     * Current position in the sample
+     * Executes a data entry fine (LSB) change for the current channel.
+     * @param dataValue The value to set for the data entry fine controller (0-127).
      */
-    cursor: number;
+    dataEntryFine: typeof dataEntryFine;
     /**
-     * MIDI root key of the sample
+     * Executes a data entry coarse (MSB) change for the current channel.
+     * @param dataValue The value to set for the data entry coarse controller (0-127).
      */
-    readonly rootKey: number;
+    dataEntryCoarse: typeof dataEntryCoarse;
+    readonly renderVoice: (voice: Voice, timeNow: number, outputL: Float32Array<ArrayBufferLike>, outputR: Float32Array<ArrayBufferLike>, reverbL: Float32Array<ArrayBufferLike>, reverbR: Float32Array<ArrayBufferLike>, chorusL: Float32Array<ArrayBufferLike>, chorusR: Float32Array<ArrayBufferLike>, startIndex: number, sampleCount: number) => void;
     /**
-     * Start position of the loop
+     * Per-note pitch wheel mode uses the pitchWheels table as source
+     * instead of the regular entry in the midiControllers table.
      */
-    loopStart: number;
+    protected perNotePitch: boolean;
     /**
-     * End position of the loop
+     * Will be updated every time something tuning-related gets changed.
+     * This is used to avoid a big addition for every voice rendering call.
      */
-    loopEnd: number;
+    protected channelTuningCents: number;
     /**
-     * End position of the sample
+     * An array of offsets generators for SF2 nrpn support.
+     * A value of 0 means no change; -10 means 10 lower, etc.
      */
-    end: number;
+    protected generatorOffsets: Int16Array;
     /**
-     * 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
+     * A small optimization that disables applying offsets until at least one is set.
      */
-    loopingMode: SampleLoopingMode;
+    protected generatorOffsetsEnabled: boolean;
     /**
-     * Indicates if the sample is currently looping
+     * An array of override generators for AWE32 support.
+     * A value of 32,767 means unchanged, as it is not allowed anywhere.
      */
-    isLooping: boolean;
+    protected generatorOverrides: Int16Array;
     /**
-     * @param data
-     * @param playbackStep the playback step, a single increment
-     * @param cursorStart the sample id which starts the playback
-     * @param rootKey MIDI root key
-     * @param loopStart loop start index
-     * @param loopEnd loop end index
-     * @param endIndex sample end index (for end offset)
-     * @param loopingMode sample looping mode
+     * A small optimization that disables applying overrides until at least one is set.
      */
-    constructor(data: Float32Array, playbackStep: number, cursorStart: number, rootKey: number, loopStart: number, loopEnd: number, endIndex: number, loopingMode: SampleLoopingMode);
-}
-
-/**
- * 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 (volumeEnvelope)
- * A modulation envelope (modulationEnvelope)
- * Generators (generators and modulatedGenerators)
- * Modulators (modulators)
- * And MIDI params such as channel, MIDI note, velocity
- */
-declare class Voice {
+    protected generatorOverridesEnabled: boolean;
+    protected readonly computeModulators: (voice: Voice, sourceUsesCC?: 0 | 1 | -1 | undefined, sourceIndex?: number | undefined) => void;
     /**
-     * The sample of the voice.
+     * For tracking voice count changes
+     * @private
      */
-    sample: AudioSample;
+    private previousVoiceCount;
     /**
-     * Lowpass filter applied to the voice.
+     * Constructs a new MIDI channel.
      */
-    filter: LowpassFilter;
+    constructor(synthProps: SynthesizerCore, preset: BasicPreset | undefined, channelNumber: number);
     /**
-     * Linear gain of the voice. Used with Key Modifiers.
+     * Indicates whether the channel is muted.
      */
-    gain: number;
+    protected _isMuted: boolean;
     /**
-     * The unmodulated (copied to) generators of the voice.
+     * Indicates whether the channel is muted.
      */
-    generators: Int16Array;
+    get isMuted(): boolean;
+    protected get channelSystem(): SynthSystem;
+    clearVoiceCount(): void;
+    updateVoiceCount(): void;
     /**
-     * The voice's modulators.
+     * Transposes the channel by given amount of semitones.
+     * @param semitones The number of semitones to transpose the channel by. Can be decimal.
+     * @param force Defaults to false, if true, it will force the transpose even if the channel is a drum channel.
      */
-    modulators: Modulator[];
+    transposeChannel(semitones: number, force?: boolean): void;
     /**
-     * Resonance offset, it is affected by the default resonant modulator
+     * Sets the octave tuning for a given channel.
+     * @param tuning The tuning array of 12 values, each representing the tuning for a note in the octave.
+     * @remarks
+     * Cent tunings are relative.
      */
-    resonanceOffset: number;
+    setOctaveTuning(tuning: Int8Array): void;
     /**
-     * The generators in real-time, affected by modulators.
-     * This is used during rendering.
+     * Sets the modulation depth for the channel.
+     * @param cents The modulation depth in cents to set.
+     * @remarks
+     * This method sets the modulation depth for the channel by converting the given cents value into a
+     * multiplier. The MIDI specification assumes the default modulation depth is 50 cents,
+     * but it may vary for different sound banks.
+     * For example, if you want a modulation depth of 100 cents,
+     * the multiplier will be 2,
+     * which, for a preset with a depth of 50,
+     * will create a total modulation depth of 100 cents.
+     *
      */
-    modulatedGenerators: Int16Array;
+    setModulationDepth(cents: number): void;
     /**
-     * Indicates if the voice is finished.
+     * Sets the channel's tuning.
+     * @param cents The tuning in cents to set.
+     * @param log If true, logs the change to the console.
      */
-    finished: boolean;
+    setTuning(cents: number, log?: boolean): void;
     /**
-     * Indicates if the voice is in the release phase.
+     * Sets the pitch of the given channel.
+     * @param pitch The pitch (0 - 16384)
+     * @param midiNote The MIDI note number, pass -1 for the regular pitch wheel
      */
-    isInRelease: boolean;
+    pitchWheel(pitch: number, midiNote?: number): void;
     /**
-     * Velocity of the note.
+     * Sets the channel pressure (MIDI Aftertouch).
+     * @param pressure the pressure of the channel.
      */
-    velocity: number;
+    channelPressure(pressure: number): void;
     /**
-     * MIDI note number.
+     * Sets the pressure of the given note on a specific channel.
+     * This is used for polyphonic pressure (aftertouch).
+     * @param midiNote 0 - 127, the MIDI note number to set the pressure for.
+     * @param pressure 0 - 127, the pressure value to set for the note.
      */
-    midiNote: number;
+    polyPressure(midiNote: number, pressure: number): void;
+    setCustomController(type: CustomController, value: number): void;
+    updateChannelTuning(): void;
     /**
-     * The pressure of the voice
+     * Locks or unlocks the preset from MIDI program changes.
+     * @param locked If the preset should be locked.
      */
-    pressure: number;
+    setPresetLock(locked: boolean): void;
     /**
-     * Target key for the note.
+     * Changes the preset to, or from drums.
+     * Note that this executes a program change.
+     * @param isDrum If the channel should be a drum preset or not.
      */
-    targetKey: number;
+    setDrums(isDrum: boolean): void;
     /**
-     * Modulation envelope.
+     * Sets the channel to a given MIDI patch.
+     * Note that this executes a program change.
+     * @param patch The MIDI patch to set the channel to.
      */
-    modulationEnvelope: ModulationEnvelope;
+    setPatch(patch: MIDIPatch): void;
     /**
-     * Volume envelope.
+     * Sets the GM/GS drum flag.
+     * @param drums
      */
-    volumeEnvelope: VolumeEnvelope;
+    setGSDrums(drums: boolean): void;
     /**
-     * Start time of the voice, absolute.
+     * Sets a custom vibrato.
+     * @param depth In cents.
+     * @param rate In Hertz.
+     * @param delay seconds.
      */
-    startTime: number;
+    setVibrato(depth: number, rate: number, delay: number): void;
     /**
-     * Start time of the release phase, absolute.
+     * Disables and locks all GS NPRN parameters, including the custom vibrato.
      */
-    releaseStartTime: number;
+    disableAndLockGSNRPN(): void;
+    resetGeneratorOverrides(): void;
+    setGeneratorOverride(gen: GeneratorType, value: number, realtime?: boolean): void;
+    resetGeneratorOffsets(): void;
+    setGeneratorOffset(gen: GeneratorType, value: number): void;
     /**
-     * Current tuning in cents.
+     * Stops a note nearly instantly.
+     * @param midiNote The note to stop.
+     * @param releaseTime in timecents, defaults to -12000 (very short release).
      */
-    currentTuningCents: number;
+    killNote(midiNote: number, releaseTime?: number): void;
     /**
-     * Current calculated tuning. (as in ratio)
+     * Stops all notes on the channel.
+     * @param force If true, stops all notes immediately, otherwise applies release time.
      */
-    currentTuningCalculated: number;
+    stopAllNotes(force?: boolean): void;
     /**
-     * From -500 to 500.
+     * Mutes or unmutes a channel.
+     * @param isMuted If the channel should be muted.
      */
-    currentPan: number;
+    muteChannel(isMuted: boolean): void;
     /**
-     * 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
+     * Sends this channel's property
      */
-    realKey: number;
+    sendChannelProperty(): void;
+    protected computeModulatorsAll(sourceUsesCC: -1 | 0 | 1, sourceIndex: number): void;
+    protected setBankMSB(bankMSB: number): void;
+    protected setBankLSB(bankLSB: number): void;
     /**
-     * Initial key to glide from, MIDI Note number. If -1, the portamento is OFF.
+     * Sets drums on channel.
      */
-    portamentoFromKey: number;
+    protected setDrumFlag(isDrum: boolean): void;
+}
+
+/**
+ * Processor.ts
+ * purpose: the core synthesis engine
+ */
+declare class SpessaSynthProcessor {
     /**
-     * Duration of the linear glide, in seconds.
+     * Controls if the processor is fully initialized.
      */
-    portamentoDuration: number;
+    readonly processorInitialized: Promise<boolean>;
     /**
-     * From -500 to 500, where zero means disabled (use the channel pan). Used for random pan.
+     * Sample rate in Hertz.
      */
-    overridePan: number;
+    readonly sampleRate: number;
     /**
-     * Exclusive class number for hi-hats etc.
+     * Calls when an event occurs.
+     * @param event The event that occurred.
      */
-    exclusiveClass: number;
+    onEventCall?: (event: SynthProcessorEvent) => unknown;
     /**
-     * Creates a Voice.
+     * Renders float32 audio data to stereo outputs; buffer size of 128 is recommended.
+     * All float arrays must have the same length.
+     * @param outputs output stereo channels (L, R).
+     * @param reverb reverb stereo channels (L, R).
+     * @param chorus chorus stereo channels (L, R).
+     * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
+     * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
      */
-    constructor(sampleRate: number, audioSample: AudioSample, midiNote: number, velocity: number, currentTime: number, targetKey: number, realKey: number, generators: Int16Array, modulators: Modulator[]);
+    readonly renderAudio: (outputs: Float32Array[], reverb: Float32Array[], chorus: Float32Array[], startIndex?: number, sampleCount?: number) => void;
     /**
-     * Copies a voice.
+     * Renders the float32 audio data of each channel; buffer size of 128 is recommended.
+     * All float arrays must have the same length.
+     * @param reverbChannels reverb stereo channels (L, R).
+     * @param chorusChannels chorus stereo channels (L, R).
+     * @param separateChannels a total of 16 stereo pairs (L, R) for each MIDI channel.
+     * @param startIndex start offset of the passed arrays, rendering starts at this index, defaults to 0.
+     * @param sampleCount the length of the rendered buffer, defaults to float32array length - startOffset.
      */
-    static copyFrom(voice: Voice, currentTime: number, realKey: number): Voice;
+    readonly renderAudioSplit: (reverb: Float32Array[], chorus: Float32Array[], separate: Float32Array[][], startIndex?: number, sampleCount?: number) => void;
     /**
-     * Releases the voice as exclusiveClass.
+     * Core synthesis engine.
      */
-    exclusiveRelease(currentTime: number): void;
+    private readonly synthCore;
     /**
-     * Stops the voice
-     * @param currentTime
-     * @param minNoteLength minimum note length in seconds
+     * Tor applying the snapshot after an override sound bank too.
      */
-    release(currentTime: number, minNoteLength?: number): void;
-}
-/**
- * @param preset the preset to get voices for
- * @param midiNote the MIDI note to use
- * @param velocity the velocity to use
- * @param realKey the real MIDI note if the "midiNote" was changed by MIDI Tuning Standard
- * @returns output is an array of Voices
- */
-declare function getVoicesForPresetInternal(this: SpessaSynthProcessor, preset: BasicPreset, midiNote: number, velocity: number, realKey: number): VoiceList;
-
-declare class ModulatorSource {
+    private savedSnapshot?;
     /**
-     * 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.
+     * Creates a new synthesizer engine.
+     * @param sampleRate sample rate, in Hertz.
+     * @param opts the processor's options.
      */
-    isBipolar: boolean;
+    constructor(sampleRate: number, opts?: Partial<SynthProcessorOptions>);
     /**
-     * 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.
+     * Are the chorus and reverb effects enabled?
      */
-    isNegative: boolean;
+    get enableEffects(): boolean;
     /**
-     * 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.
+     * Are the chorus and reverb effects enabled?
      */
-    index: ModulatorSourceIndex;
+    set enableEffects(v: boolean);
     /**
-     * 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.
+     * Is the event system enabled?
      */
-    isCC: boolean;
+    get enableEventSystem(): boolean;
     /**
-     * This field specifies how the minimum value approaches the maximum value.
+     * Is the event system enabled?
      */
-    curveType: ModulatorCurveType;
-    constructor(index?: ModulatorSourceIndex, curveType?: ModulatorCurveType, isCC?: boolean, isBipolar?: boolean, isNegative?: boolean);
-    private get sourceName();
-    private get curveTypeName();
-    static fromSourceEnum(sourceEnum: number): ModulatorSource;
+    set enableEventSystem(v: boolean);
     /**
-     * Copies the modulator source.
-     * @param source The source to copy from.
-     * @returns the copied source.
+     * All MIDI channels of the synthesizer.
      */
-    static copyFrom(source: ModulatorSource): ModulatorSource;
-    toString(): string;
-    toSourceEnum(): number;
-    isIdentical(source: ModulatorSource): boolean;
+    get midiChannels(): MIDIChannel[];
     /**
-     * Gets the current value from this source.
-     * @param midiControllers The MIDI controller + modulator source array.
-     * @param voice The voice to get the data for.
+     * Current total amount of voices that are currently playing.
      */
-    getValue(midiControllers: Int16Array, voice: Voice): number;
-}
-
-declare class Modulator {
+    get totalVoicesAmount(): number;
     /**
-     * The current computed value of this modulator. Only used in the synthesis engine for local voices.
+     * The current time of the synthesizer, in seconds. You probably should not modify this directly.
      */
-    currentValue: number;
+    get currentSynthTime(): number;
     /**
-     * The generator destination of this modulator.
+     * The sound bank manager, which manages all sound banks and presets.
      */
-    destination: GeneratorType;
+    get soundBankManager(): SoundBankManager;
     /**
-     * The transform amount for this modulator.
+     * Handles the custom key overrides: velocity and preset
      */
-    transformAmount: number;
+    get keyModifierManager(): KeyModifierManager;
     /**
-     * The transform type for this modulator.
+     * A handler for missing presets during program change. By default, it warns to console.
+     * @param patch The MIDI patch that was requested.
+     * @param system The MIDI System for the request.
+     * @returns If a BasicPreset instance is returned, it will be used by the channel.
      */
-    transformType: ModulatorTransformType;
+    onMissingPreset: (patch: MIDIPatch, system: SynthSystem) => BasicPreset | undefined;
     /**
-     * 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
+     * Executes a system exclusive message for the synthesizer.
+     * @param syx The system exclusive message as an array of bytes.
+     * @param channelOffset The channel offset to apply (default is 0).
      */
-    readonly isEffectModulator: boolean;
+    systemExclusive(syx: SysExAcceptedArray, channelOffset?: number): void;
     /**
-     * The default resonant modulator does not affect the filter gain.
-     * Neither XG nor GS responded to cc #74 in that way.
+     * Sets a master parameter of the synthesizer.
+     * @param type The type of the master parameter to set.
+     * @param value The value to set for the master parameter.
      */
-    readonly isDefaultResonantModulator: boolean;
+    setMasterParameter<P extends keyof MasterParameterType>(type: P, value: MasterParameterType[P]): void;
     /**
-     * The primary source of this modulator.
+     * Gets a master parameter of the synthesizer.
+     * @param type The type of the master parameter to get.
+     * @returns The value of the master parameter.
      */
-    readonly primarySource: ModulatorSource;
+    getMasterParameter<P extends keyof MasterParameterType>(type: P): MasterParameterType[P];
     /**
-     * The secondary source of this modulator.
+     * Gets all master parameters of the synthesizer.
+     * @returns All the master parameters.
      */
-    readonly secondarySource: ModulatorSource;
+    getAllMasterParameters(): MasterParameterType;
     /**
-     * Creates a new SF2 Modulator
+     * Executes a full system reset of all controllers.
+     * This will reset all controllers to their default values,
+     * except for the locked controllers.
      */
-    constructor(primarySource?: ModulatorSource, secondarySource?: ModulatorSource, destination?: GeneratorType, amount?: number, transformType?: ModulatorTransformType, isEffectModulator?: boolean, isDefaultResonantModulator?: boolean);
-    private get destinationName();
+    resetAllControllers(system?: SynthSystem): void;
     /**
-     * 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
+     * Applies the snapshot to the synth
      */
-    static isIdentical(mod1: Modulator, mod2: Modulator, checkAmount?: boolean): boolean;
+    applySynthesizerSnapshot(snapshot: SynthesizerSnapshot): void;
     /**
-     * Copies a modulator.
-     * @param mod The modulator to copy.
-     * @returns The copied modulator.
+     * Gets a synthesizer snapshot from this processor instance.
      */
-    static copyFrom(mod: Modulator): Modulator;
-    toString(): string;
-    write(modData: IndexedByteArray, indexes?: SoundFontWriteIndexes): void;
+    getSnapshot(): SynthesizerSnapshot;
     /**
-     * Sums transform and create a NEW modulator
-     * @param modulator the modulator to sum with
-     * @returns the new modulator
+     * Sets the embedded sound bank.
+     * @param bank The sound bank file to set.
+     * @param offset The bank offset of the embedded sound bank.
      */
-    sumTransform(modulator: Modulator): Modulator;
-}
-
-/**
- * Midi_message.ts
- * purpose: contains enums for midi events and controllers and functions to parse them
- */
-
-declare class MIDIMessage {
+    setEmbeddedSoundBank(bank: ArrayBuffer, offset: number): void;
+    clearEmbeddedBank(): void;
+    createMIDIChannel(): void;
     /**
-     * Absolute number of MIDI ticks from the start of the track.
+     * Stops all notes on all channels.
+     * @param force if true, all notes are stopped immediately, otherwise they are stopped gracefully.
      */
-    ticks: number;
+    stopAllChannels(force?: boolean): void;
     /**
-     * The MIDI message status byte. Note that for meta events, it is the second byte. (not 0xFF)
+     *  Destroy the synthesizer processor, clearing all channels and voices.
+     *  This is irreversible, so use with caution.
      */
-    statusByte: MIDIMessageType;
+    destroySynthProcessor(): void;
     /**
-     * Message's binary data
+     * Executes a MIDI controller change message on the specified channel.
+     * @param channel The MIDI channel to change the controller on.
+     * @param controllerNumber The MIDI controller number to change.
+     * @param controllerValue The value to set the controller to.
      */
-    data: Uint8Array<ArrayBuffer>;
+    controllerChange(channel: number, controllerNumber: MIDIController, controllerValue: number): void;
     /**
-     * Creates a new MIDI message
-     * @param ticks time of this message in absolute MIDI ticks
-     * @param byte the message status byte
-     * @param data the message's binary data
+     * Executes a MIDI Note-on message on the specified channel.
+     * @param channel The MIDI channel to send the note on.
+     * @param midiNote The MIDI note number to play.
+     * @param velocity The velocity of the note, from 0 to 127.
+     * @remarks
+     * If the velocity is 0, it will be treated as a Note-off message.
      */
-    constructor(ticks: number, byte: MIDIMessageType, data: Uint8Array<ArrayBuffer>);
-}
-
-/**
- * RMIDInfoData type represents metadata for an RMIDI file.
- */
-interface RMIDInfoData {
+    noteOn(channel: number, midiNote: number, velocity: number): void;
     /**
-     * The name of the song.
+     * Executes a MIDI Note-off message on the specified channel.
+     * @param channel The MIDI channel to send the note off.
+     * @param midiNote The MIDI note number to stop playing.
      */
-    name: string;
+    noteOff(channel: number, midiNote: number): void;
     /**
-     * The engineer who worked on the sound bank file.
+     * Executes a MIDI Poly Pressure (Aftertouch) message on the specified channel.
+     * @param channel The MIDI channel to send the poly pressure on.
+     * @param midiNote The MIDI note number to apply the pressure to.
+     * @param pressure The pressure value, from 0 to 127.
      */
-    engineer: string;
+    polyPressure(channel: number, midiNote: number, pressure: number): void;
     /**
-     * The artist of the MIDI file.
+     * Executes a MIDI Channel Pressure (Aftertouch) message on the specified channel.
+     * @param channel The MIDI channel to send the channel pressure on.
+     * @param pressure The pressure value, from 0 to 127.
      */
-    artist: string;
+    channelPressure(channel: number, pressure: number): void;
     /**
-     * The album of the song.
+     * Executes a MIDI Pitch Wheel message on the specified channel.
+     * @param channel The MIDI channel to send the pitch wheel on.
+     * @param pitch The new pitch value: 0-16384
+     * @param midiNote The MIDI note number, pass -1 for the regular pitch wheel
      */
-    album: string;
+    pitchWheel(channel: number, pitch: number, midiNote?: number): void;
     /**
-     * The genre of the song.
+     * Executes a MIDI Program Change message on the specified channel.
+     * @param channel The MIDI channel to send the program change on.
+     * @param programNumber The program number to change to, from 0 to 127.
      */
-    genre: string;
+    programChange(channel: number, programNumber: number): void;
     /**
-     * The image for the file (album cover).
+     * DEPRECATED, does nothing!
+     * @param amount
+     * @deprecated
      */
-    picture: ArrayBuffer;
+    killVoices(amount: number): void;
     /**
-     * The comment of the file.
+     * Processes a raw MIDI message.
+     * @param message The message to process.
+     * @param channelOffset The channel offset for the message.
+     * @param force If true, forces the message to be processed.
+     * @param options Additional options for scheduling the message.
      */
-    comment: string;
+    processMessage(message: Uint8Array | number[], channelOffset?: number, force?: boolean, options?: SynthMethodOptions): void;
     /**
-     * The creation date of the file.
+     * Clears the synthesizer's voice cache.
      */
-    creationDate: Date;
+    clearCache(): void;
     /**
-     * The copyright of the file.
+     * Gets voices for a preset.
+     * @param preset The preset to get voices for.
+     * @param midiNote The MIDI note to use.
+     * @param velocity The velocity to use.
+     * @returns Output is an array of voices.
+     * @remarks
+     * This is a public method, but it is only intended to be used by the sequencer.
+     * @internal
      */
-    copyright: string;
+    getVoicesForPreset(preset: BasicPreset, midiNote: number, velocity: number): CachedVoiceList;
     /**
-     * The encoding of the RMIDI info.
+     * Calls synth event
+     * @param eventName the event name
+     * @param eventData the event data
      */
-    infoEncoding: string;
+    private callEvent;
+    private missingPreset;
+}
+
+/**
+ * Represents a snapshot of a single channel's state in the synthesizer.
+ */
+declare class ChannelSnapshot {
     /**
-     * The encoding of the MIDI file's text messages.
+     * The MIDI patch that the channel is using.
      */
-    midiEncoding: string;
+    patch: MIDIPatchNamed;
     /**
-     * The software used to write the file.
+     * Indicates whether the channel's program change is disabled.
      */
-    software: string;
+    lockPreset: boolean;
     /**
-     * The subject of the file.
+     * Indicates the MIDI system when the preset was locked
      */
-    subject: string;
-}
-interface TempoChange {
+    lockedSystem: SynthSystem;
     /**
-     * MIDI ticks of the change, absolute value from the start of the MIDI file.
+     * The array of all MIDI controllers (in 14-bit values) with the modulator sources at the end.
      */
-    ticks: number;
+    midiControllers: Int16Array;
     /**
-     * New tempo in BPM.
+     * An array of booleans, indicating if the controller with a current index is locked.
      */
-    tempo: number;
-}
-type MIDILoopType = "soft" | "hard";
-interface MIDILoop {
+    lockedControllers: boolean[];
     /**
-     * Start of the loop, in MIDI ticks.
+     * Array of custom (not SF2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
      */
-    start: number;
+    customControllers: Float32Array;
     /**
-     * End of the loop, in MIDI ticks.
+     * Indicates whether the channel vibrato is locked.
      */
-    end: number;
+    lockVibrato: boolean;
     /**
-     * The type of the loop detected:
-     * - Soft - the playback will immediately jump to the loop start pointer without any further processing.
-     * - Hard - the playback will quickly process all messages from
-     * the start of the file to ensure that synthesizer is in the correct state.
-     * This is the default behavior.
-     *
-     * Soft loop types are enabled for Touhou and GameMaker loop points.
+     * The channel's vibrato settings.
+     * @property depth Vibrato depth, in gain.
+     * @property delay Vibrato delay from note on in seconds.
+     * @property rate Vibrato rate in Hz.
      */
-    type: MIDILoopType;
-}
-type MIDIFormat = 0 | 1 | 2;
-interface NoteTime {
+    channelVibrato: {
+        depth: number;
+        delay: number;
+        rate: number;
+    };
     /**
-     * The MIDI key number.
+     * Key shift for the channel.
      */
-    midiNote: number;
+    channelTransposeKeyShift: number;
     /**
-     * Start of the note, in seconds.
+     * The channel's octave tuning in cents.
      */
-    start: number;
+    channelOctaveTuning: Int8Array;
     /**
-     * Length of the note, in seconds.
+     * Indicates whether the channel is muted.
      */
-    length: number;
+    isMuted: boolean;
     /**
-     * The MIDI velocity of the note.
+     * Indicates whether the channel is a drum channel.
      */
-    velocity: number;
-}
-/**
- * Represents a desired program change for a MIDI channel.
- */
-interface DesiredProgramChange extends MIDIPatch {
+    drumChannel: boolean;
     /**
-     * The channel number.
+     * The channel number this snapshot represents.
      */
-    channel: number;
-}
-/**
- * Represents a desired controller change for a MIDI channel.
- */
-interface DesiredControllerChange {
+    channelNumber: number;
+    constructor(patch: MIDIPatchNamed, lockPreset: boolean, lockedSystem: SynthSystem, midiControllers: Int16Array, lockedControllers: boolean[], customControllers: Float32Array, lockVibrato: boolean, channelVibrato: {
+        delay: number;
+        depth: number;
+        rate: number;
+    }, channelTransposeKeyShift: number, channelOctaveTuning: Int8Array, isMuted: boolean, drumChannel: boolean, channelNumber: number);
     /**
-     * The channel number.
+     * Creates a copy of existing snapshot.
+     * @param snapshot The snapshot to create a copy from.
      */
-    channel: number;
+    static copyFrom(snapshot: ChannelSnapshot): ChannelSnapshot;
     /**
-     * The MIDI controller number.
+     * Creates a snapshot of the channel's state.
+     * @param spessaSynthProcessor The synthesizer processor containing the channel.
+     * @param channelNumber The channel number to take a snapshot of.
      */
-    controllerNumber: number;
+    static create(spessaSynthProcessor: SpessaSynthProcessor, channelNumber: number): ChannelSnapshot;
     /**
-     * The new controller value.
+     * Applies the snapshot to the specified channel.
+     * @param spessaSynthProcessor The processor containing the channel.
      */
-    controllerValue: number;
+    apply(spessaSynthProcessor: SpessaSynthProcessor): void;
 }
+
 /**
- * Represents a desired channel transpose change.
+ * Represents a snapshot of the synthesizer's state.
  */
-interface DesiredChannelTranspose {
-    /**
-     * The channel number.
-     */
-    channel: number;
+declare class SynthesizerSnapshot {
     /**
-     * The number of semitones to transpose.
-     * This can use floating point numbers, which will be used to fine-tune the pitch in cents using RPN.
+     * The individual channel snapshots.
      */
-    keyShift: number;
-}
-interface RMIDIWriteOptions {
+    channelSnapshots: ChannelSnapshot[];
     /**
-     * The bank offset for RMIDI.
+     * Key modifiers.
      */
-    bankOffset: number;
+    keyMappings: (KeyModifier | undefined)[][];
+    masterParameters: MasterParameterType;
+    constructor(channelSnapshots: ChannelSnapshot[], masterParameters: MasterParameterType, keyMappings: (KeyModifier | undefined)[][]);
     /**
-     * The metadata of the file. Optional.
+     * Creates a new synthesizer snapshot from the given SpessaSynthProcessor.
+     * @param processor the processor to take a snapshot of.
+     * @returns The snapshot.
      */
-    metadata: Partial<Omit<RMIDInfoData, "infoEncoding">>;
+    static create(processor: SpessaSynthProcessor): SynthesizerSnapshot;
     /**
-     * If the MIDI file should internally be corrected to work with the set bank offset.
+     * Creates a copy of existing snapshot.
+     * @param snapshot The snapshot to create a copy from.
      */
-    correctBankOffset: boolean;
+    static copyFrom(snapshot: SynthesizerSnapshot): SynthesizerSnapshot;
     /**
-     * The optional sound bank instance used to correct bank offset.
+     * Applies the snapshot to the synthesizer.
+     * @param processor the processor to apply the snapshot to.
      */
-    soundBank?: BasicSoundBank;
+    apply(processor: SpessaSynthProcessor): void;
 }
-type RMIDInfoFourCC = "INAM" | "IPRD" | "IALB" | "IART" | "IGNR" | "IPIC" | "ICOP" | "ICRD" | "ICRT" | "ICMT" | "IENG" | "ISFT" | "ISBJ" | "IENC" | "MENC" | "DBNK";
 
 declare class MIDITrack {
     /**
@@ -3212,6 +3432,12 @@ declare class BasicMIDI {
      * @returns The time in seconds.
      */
     midiTicksToSeconds(ticks: number): number;
+    /**
+     * Converts seconds to time in MIDI ticks.
+     * @param seconds The time in seconds.
+     * @returns The time in MIDI ticks.
+     */
+    secondsToMIDITicks(seconds: number): number;
     /**
      * Gets the used programs and keys for this MIDI file with a given sound bank.
      * @param soundbank the sound bank.
@@ -3502,9 +3728,8 @@ interface SoundBankInfoData {
     romVersion?: SF2VersionTag;
 }
 type SoundBankInfoFourCC = keyof SoundBankInfoData;
-interface VoiceSynthesisData {
-    instrumentGenerators: Generator[];
-    presetGenerators: Generator[];
+interface VoiceParameters {
+    generators: Int16Array;
     modulators: Modulator[];
     sample: BasicSample;
 }
@@ -3737,20 +3962,6 @@ declare class MIDIBuilder extends BasicMIDI {
     addPitchWheel(ticks: number, track: number, channel: number, MSB: number, LSB: number): void;
 }
 
-/**
- * Processes a single MIDI tick.
- * Call this every rendering quantum to process the sequencer events in real-time.
- */
-declare function processTick(this: SpessaSynthSequencer): void;
-
-/**
- * Plays the MIDI file to a specific time or ticks.
- * @param time in seconds.
- * @param ticks optional MIDI ticks, when given is used instead of time.
- * @returns true if the MIDI file is not finished.
- */
-declare function setTimeToInternal(this: SpessaSynthSequencer, time: number, ticks?: number | undefined): boolean;
-
 interface SequencerEventData {
     /**
      * Called when a MIDI message is sent and externalMIDIPlayback is true.
@@ -3760,6 +3971,11 @@ interface SequencerEventData {
          * The binary MIDI message.
          */
         message: Iterable<number>;
+        /**
+         * The synthesizer's current time when this event was sent.
+         * Use this for scheduling MIDI messages to your external MIDI device.
+         */
+        time: number;
     };
     /**
      * Called when the time is changed.
@@ -3833,6 +4049,20 @@ type SequencerEvent = {
     };
 }[keyof SequencerEventData];
 
+/**
+ * Processes a single MIDI tick.
+ * Call this every rendering quantum to process the sequencer events in real-time.
+ */
+declare function processTick(this: SpessaSynthSequencer): void;
+
+/**
+ * Plays the MIDI file to a specific time or ticks.
+ * @param time in seconds.
+ * @param ticks optional MIDI ticks, when given is used instead of time.
+ * @returns true if the MIDI file is not finished.
+ */
+declare function setTimeToInternal(this: SpessaSynthSequencer, time: number, ticks?: number | undefined): boolean;
+
 declare class SpessaSynthSequencer {
     /**
      * Sequencer's song list.
@@ -4068,14 +4298,6 @@ declare class SpessaSynthSequencer {
     protected sendMIDIPitchWheel(channel: number, pitch: number): void;
 }
 
-declare const DEFAULT_MASTER_PARAMETERS: MasterParameterType;
-
-/**
- * Default MIDI drum channel.
- */
-declare const DEFAULT_PERCUSSION = 9;
-declare const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
-
 declare const NON_CC_INDEX_OFFSET = 128;
 declare const CONTROLLER_TABLE_SIZE = 147;
 /**
@@ -4086,6 +4308,14 @@ declare const setResetValue: (i: MIDIController, v: number) => number;
 declare const CUSTOM_CONTROLLER_TABLE_SIZE: number;
 declare const customResetArray: Float32Array<ArrayBuffer>;
 
+declare const DEFAULT_MASTER_PARAMETERS: MasterParameterType;
+
+/**
+ * Default MIDI drum channel.
+ */
+declare const DEFAULT_PERCUSSION = 9;
+declare const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
+
 declare class SoundBankLoader {
     /**
      * Loads a sound bank from a file buffer.
@@ -4096,4 +4326,4 @@ declare class SoundBankLoader {
     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 ChannelPressureCallback, type ChannelProperty, type ChannelPropertyChangeCallback, ChannelSnapshot, 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 DesiredChannelTranspose, type DesiredControllerChange, type DesiredProgramChange, type DrumChangeCallback, EmptySample, type FourCC, GENERATORS_AMOUNT, Generator, type GeneratorType, type GenericBankInfoFourCC, type GenericRIFFFourCC, type GenericRange, IndexedByteArray, type InterpolationType, KeyModifier, MAX_GENERATOR, MIDIBuilder, type MIDIController, type MIDIFormat, type MIDILoop, type MIDILoopType, MIDIMessage, type MIDIMessageType, type MIDIPatch, type MIDIPatchNamed, MIDIPatchTools, MIDITrack, type MTSNoteTuning, type MTSProgramTuning, 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 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 VoiceList, type VoiceSynthesisData, type WaveMetadata, type WaveWriteOptions, audioToWav, customControllers, customResetArray, dataEntryStates, defaultMIDIControllerValues, dlsDestinations, dlsSources, generatorLimits, generatorTypes, interpolationTypes, midiControllers, midiMessageTypes, modulatorCurveTypes, modulatorSources, modulatorTransformTypes, sampleTypes, setResetValue };
+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 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 DesiredChannelTranspose, type DesiredControllerChange, type DesiredProgramChange, type DrumChangeCallback, EmptySample, type FourCC, GENERATORS_AMOUNT, Generator, type GeneratorType, type GenericBankInfoFourCC, type GenericRIFFFourCC, type GenericRange, IndexedByteArray, 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 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, generatorLimits, generatorTypes, interpolationTypes, midiControllers, midiMessageTypes, modulatorCurveTypes, modulatorSources, modulatorTransformTypes, sampleTypes, setResetValue };