spessasynth_core 4.3.5 → 4.3.7

package/dist/index.d.ts

@@ -1416,10 +1416,6 @@ interface InsertionProcessorSnapshot {
    * 20 parameters for the effect, 255 means "no change" + 3 effect sends (index 20, 21, 22)
    */
   params: Uint8Array;
-  /**
-   * A boolean list for channels that have the insertion effect enabled.
-   */
-  channels: boolean[];
 }
 type InsertionProcessorConstructor = new (sampleRate: number, maxBufferSize: number) => InsertionProcessor;
 //#endregion
@@ -1628,545 +1624,627 @@ declare const NonRegisteredLSB: {
   readonly envelopeReleaseTime: 102;
 };
 //#endregion
-//#region src/synthesizer/audio_engine/channel/parameters/midi.d.ts
-interface ChannelMIDIParameter {
-  /**
-   * The current pressure (aftertouch) of this channel.
-   */
-  pressure: number;
+//#region src/synthesizer/audio_engine/channel/awe32_nrpn.d.ts
+interface ChannelGenerators {
   /**
-   * The current pitch wheel value (0-16,383) of this channel.
+   * An array of offsets generators for SF2 NRPN support.
+   * A value of 0 means no change; -10 means 10 lower, etc.
    */
-  pitchWheel: number;
+  offsets: Int16Array;
   /**
-   * The current pitch wheel range, in semitones.
+   * A small optimization that disables applying offsets until at least one is set.
    */
-  pitchWheelRange: number;
+  offsetsEnabled: boolean;
   /**
-   * The multiplier of the modulation wheel modulator.
-   *
-   * The MIDI specification assumes the default modulation depth is 50 cents,
-   * but it may vary for different sound banks.
-   * For example, if a MIDI requests 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.
+   * An array of overrides generators for AWE32 NRPN support.
+   * A value of GENERATOR_OVERRIDE_NO_CHANGE_VALUE (-32,767) means no change;
+   * other values replace current generators.
    */
-  modulationDepth: number;
+  overrides: Int16Array;
   /**
-   * The channel's receiving number (0-based index).
-   * This allows triggering multiple parts (channels) with a single note message.
-   * @remarks
-   * Only used when customChannelNumbers is enabled.
+   * A small optimization that disables applying overrides until at least one is set.
    */
-  rxChannel: number;
+  overridesEnabled: boolean;
+}
+//#endregion
+//#region src/synthesizer/enums.d.ts
+/**
+ * The available interpolation types of the synthesizer.
+ */
+declare const InterpolationTypes: {
+  readonly linear: 0;
+  readonly nearestNeighbor: 1;
+  readonly hermite: 2;
+};
+type InterpolationType = (typeof InterpolationTypes)[keyof typeof InterpolationTypes];
+//#endregion
+//#region src/synthesizer/audio_engine/channel/parameters/system.d.ts
+/**
+ * The system parameters of the channel.
+ * These can only be changed via the API.
+ */
+interface ChannelSystemParameter {
   /**
-   * 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.
+   * If the preset is locked, preventing any program changes from being sent.
    */
-  polyMode: boolean;
+  presetLock: boolean;
   /**
-   * The key shift of the channel (in semitones).
-   * Drum channels ignore this value.
+   * If the channel should not produce any sound
+   * and ignore incoming Note On messages.
    */
-  keyShift: number;
+  isMuted: boolean;
   /**
-   * Cents, RPN/SysEx for fine-tuning.
-   * Drum channels ignore this value.
+   * The gain for the channel.
+   * From 0 to any number. 1 is 100% volume.
    */
-  fineTune: number;
+  gain: number;
   /**
-   * Enables random panning for every note played on this channel.
+   * The panning of the channel.
+   * -1 (left) to 1 (right). 0 is center.
    */
-  randomPan: boolean;
+  pan: number;
   /**
-   * Assign mode for the channel.
-   * `ASSIGN MODE` is the parameter that determines how voice assignment will be handled when sounds overlap on identical note numbers in the same channel (i.e., repeatedly struck notes).
-   * This is initialized to a mode suitable for each Part, so for general purposes there is no need to change this.
-   *
-   * - 0 - Single: If the same note is played multiple times in succession, the previously-sounding note will be completely silenced, and then the new note will be sounded.
-   * - 1 - LimitedMulti: If the same note is played multiple times in succession, the previously-sounding note will be continued to a certain extent even after the new note is sounded. (Default setting)
-   * - 2 - FullMulti: If the same note is played multiple times in succession, the previously-sounding note(s) will continue sounding for their natural length even after the new note is sounded.
-   *
-   * SpessaSynth treats LimitedMulti like FullMulti.
-   * Essentially Limited and Full are normal
-   * and Single is like `monophonicRetrigger` system parameter.
+   * The channel key shift in semitones.
+   * Drum channels DO NOT ignore this value.
    */
-  assignMode: number;
+  keyShift: number;
   /**
-   * Indicates whether this channel uses the insertion EFX processor.
+   * The channel tuning in cents.
+   * Drum channels DO NOT ignore this value.
    */
-  efxAssign: boolean;
+  fineTune: number;
   /**
-   * CC1 for GS controller matrix.
-   * An arbitrary MIDI controller, which can be bound to any synthesis parameter.
-   * Default is 16.
+   * The interpolation type used for sample playback.
+   *
+   * Overrides the global parameter if set.
    */
-  cc1: MIDIController;
+  interpolationType: InterpolationType | null;
   /**
-   * CC2 for GS controller matrix.
-   * An arbitrary MIDI controller, which can be bound to any synthesis parameter.
-   * Default is 17.
+   * If the channel should prevent changing any parameters via NRPN.
+   *
+   * Overrides the global parameter if set.
    */
-  cc2: MIDIController;
+  nrpnParamLock: boolean | null;
   /**
-   * Drum map for GS system exclusive tracking.
-   * Only used for selecting the correct channel when setting drum parameters through sysEx,
-   * as those don't specify the channel, but the drum number.
+   * Indicates whether the channel is in monophonic retrigger mode.
+   * This emulates the behavior of Microsoft GS Wavetable Synth,
+   * Where a new note will kill the previous one if it is still playing.
    *
-   * The only values that are allowed are 0 (melodic) 1 or 2.
+   * Overrides the global parameter if set.
    */
-  drumMap: number;
+  monophonicRetrigger: boolean | null;
 }
-declare const DEFAULT_CHANNEL_MIDI_PARAMETERS: ChannelMIDIParameter;
+declare const DEFAULT_CHANNEL_SYSTEM_PARAMETERS: ChannelSystemParameter;
+/**
+ * Sets a system parameter of the channel
+ * @param parameter The type of the system parameter to set.
+ * @param value The value to set for the system parameter.
+ */
+declare function setSystemParameterInternal<P extends keyof ChannelSystemParameter>(this: MIDIChannel, parameter: P, value: ChannelSystemParameter[P]): void;
 //#endregion
-//#region src/synthesizer/audio_engine/channel/types.d.ts
-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 ProgramChangeCallback extends MIDIPatchFull {
-  /** The MIDI channel number. */
-  channel: number;
-}
-interface ControllerChangeCallback {
-  /** The MIDI channel number. */
-  channel: number;
-  /** The controller number. */
-  controller: MIDIController;
-  /** The value of the controller. */
-  value: number;
-}
-interface PolyPressureCallback {
-  /** The MIDI channel number. */
-  channel: number;
-  /** The MIDI note number. */
-  midiNote: number;
-  /** The pressure value. */
-  pressure: number;
-}
-interface StopAllCallback {
+//#region src/synthesizer/audio_engine/channel/midi_channel.d.ts
+/**
+ * This class represents a single MIDI Channel within the synthesizer.
+ */
+declare class MIDIChannel {
   /**
-   * The MIDI channel 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.
    */
-  channel: number;
+  readonly patch: MIDIPatch;
   /**
-   * If the channel was force stopped. (no release time)
+   * The preset currently assigned to the channel.
+   * Note that this may be undefined in some cases.
    */
-  force: boolean;
-}
-type ChannelMIDIParameterChange = { [P in keyof ChannelMIDIParameter]: {
+  preset?: BasicPreset;
   /**
-   * The channel that was affected.
+   * The channel's number (0-based index)
    */
-  channel: number;
+  readonly channel: number;
   /**
-   * The parameter that was changed.
+   * Sets a system parameter of the channel.
+   * @param parameter The type of the system parameter to set.
+   * @param value The value to set for the system parameter.
    */
-  parameter: P;
+  readonly setSystemParameter: typeof setSystemParameterInternal;
   /**
-   * The new value of this parameter.
+   * Locks or unlocks a given Channel MIDI Parameter.
+   * This prevents any changes to it until it's unlocked.
+   * @param parameter The Channel MIDI Parameter to lock.
+   * @param isLocked If the parameter should be locked.
    */
-  value: ChannelMIDIParameter[P];
-} }[keyof ChannelMIDIParameter];
-//#endregion
-//#region src/synthesizer/enums.d.ts
-/**
- * The available interpolation types of the synthesizer.
- */
-declare const InterpolationTypes: {
-  readonly linear: 0;
-  readonly nearestNeighbor: 1;
-  readonly hermite: 2;
-};
-type InterpolationType = (typeof InterpolationTypes)[keyof typeof InterpolationTypes];
-//#endregion
-//#region src/synthesizer/audio_engine/parameters/system.d.ts
-/**
- * The global parameters of the synthesizer.
- * These can only be changed via the API.
- */
-interface GlobalSystemParameter {
+  readonly lockMIDIParameter: typeof lockMIDIParameterInternal;
   /**
-   * If the synthesizer processes the audio effects.
+   * An array of MIDI controllers for the channel.
+   * This array is used to store the state of various MIDI controllers
+   * such as volume, pan, modulation, etc.
+   * @remarks
+   * A bit of an explanation:
+   * The controller table is stored as an int16 array, it stores 14-bit values, allowing for full 14-bit LSB resolution.
+   * The only exception from this are the Registered and Non-Registered Parameter Numbers.
+   * Data entries do store it!
    */
-  effectsEnabled: boolean;
+  protected readonly _midiControllers: Int16Array;
   /**
-   * If the event system is enabled.
+   * 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.
    */
-  eventsEnabled: boolean;
+  protected readonly octaveTuning: Int8Array;
+  protected readonly _midiParameters: Readonly<ChannelMIDIParameter>;
   /**
-   * The maximum number of voices that can be played at once.
-   *
-   * Increasing this value causes memory allocation for more voices.
-   * It is recommended to set it at the beginning, before rendering audio to avoid GC.
-   * Decreasing it does not cause memory usage change, so it's fine to use.
+   * Note On message tracking, for grouping voices for specific Note On messages.
+   * Used for overlapping Note Ons.
+   * MIDI note: current note on ID
+   * @protected
    */
-  voiceCap: number;
+  protected readonly noteOnID: number[];
   /**
-   * Enabling this parameter will cause a new voice allocation when the voice cap is hit, rather than stealing existing voices.
-   *
-   * This is not recommended in real-time environments.
+   * Note Off message tracking, for grouping voices for specific Note On messages.
+   * Used for overlapping Note Ons.
+   * MIDI note: current note on ID
+   * @protected
    */
-  autoAllocateVoices: boolean;
+  protected readonly noteOffID: number[];
   /**
-   * The reverb effect gain.
-   * From 0 to any number. 1 is 100% reverb.
+   * If the last Parameter was RPN.
+   * If false then the last parameter was NRPN.
+   * @protected
    */
-  reverbGain: number;
+  protected lastParameterIsRegistered: boolean;
   /**
-   * If the synthesizer should prevent editing of the reverb parameters.
-   * This effect is modified using MIDI system exclusive messages, so
-   * the recommended use case would be setting
-   * the reverb parameters then locking it to prevent changes by MIDI files.
+   * Per-note pitch wheel mode uses the pitchWheels table as source
+   * instead of the regular entry in the midiControllers table.
    */
-  reverbLock: boolean;
+  protected perNotePitch: boolean;
   /**
-   * The chorus effect gain.
-   * From 0 to any number. 1 is 100% chorus.
+   * Current pan in range [-500;500]
+   * Updated in `updateInternalParams`.
+   * This is used to avoid a big addition for every voice rendering call.
    */
-  chorusGain: number;
+  protected currentPan: number;
   /**
-   * If the synthesizer should prevent editing of the chorus parameters.
-   * This effect is modified using MIDI system exclusive messages, so
-   * the recommended use case would be setting
-   * the chorus parameters then locking it to prevent changes by MIDI files.
+   * Current tuning in cents.
+   * Updated in `updateInternalParams`.
+   * This is used to avoid a big addition for every voice rendering call.
    */
-  chorusLock: boolean;
+  protected currentTuning: number;
   /**
-   * The delay effect gain.
-   * From 0 to any number. 1 is 100% delay.
+   * Current key-shift.
+   * Updated in `updateInternalParams`.
    */
-  delayGain: number;
+  protected currentKeyShift: number;
   /**
-   * If the synthesizer should prevent editing of the delay parameters.
-   * This effect is modified using MIDI system exclusive messages, so
-   * the recommended use case would be setting
-   * the delay parameters then locking it to prevent changes by MIDI files.
+   * Current gain.
+   * Updated in `updateInternalParams`.
+   * This is used to avoid a big multiplication for every voice rendering call.
    */
-  delayLock: boolean;
+  protected currentGain: number;
   /**
-   * If the synthesizer should prevent changing the insertion effect type and parameters (including enabling/disabling it on channels).
-   * This effect is modified using MIDI system exclusive messages, so
-   * the recommended use case would be setting
-   * the insertion effect type and parameters then locking it to prevent changes by MIDI files.
+   * The last pressed note on this channel for portamento tracking.
+   * -1 means none.
+   * This is not a `ChannelMIDIParameter` and is strictly internal,
+   * mostly because we don't want to send events for every note on message.
+   * It can be set with Portamento Control CC anyway.
+   * @protected
    */
-  insertionEffectLock: boolean;
+  protected lastPortamentoNote: number;
   /**
-   * If the synthesizer should prevent editing of the drum parameters.
-   * These params are modified using MIDI system exclusive messages or NRPN, so
-   * the recommended use case would be setting
-   * the drum parameters then locking it to prevent changes by MIDI files.
+   * If the portamento should be executed once regardless of Portamento on/off.
+   * Adhering to the MIDI spec, CC#84 ignores on/off.
+   * This is also not a `ChannelMIDIParameter` for the same reason as `lastPortamentoNote`
+   * @protected
    */
-  drumLock: boolean;
+  protected portamentoForce: boolean;
   /**
-   * Forces note killing instead of releasing. Improves performance in black MIDIs.
+   * The last pressed note on this channel in mono mode.
+   * Used for tracking and releasing this note on a new Note On event.
+   * -1 means none.
+   * @protected
    */
-  blackMIDIMode: boolean;
+  protected lastMonoNote: number;
   /**
-   * Synthesizer's device ID for system exclusive messages. Set to -1 to accept all.
+   * The last pressed note's velocity on this channel in mono mode.
+   * @protected
    */
-  deviceID: number;
+  protected lastMonoVelocity: number;
   /**
-   * The master gain.
-   * From 0 to any number. 1 is 100% volume.
+   * For Mono Mode restoring notes.
+   * playingNotes[midiNote]
+   * @protected
    */
-  gain: number;
+  protected readonly playingNotes: boolean[];
+  protected readonly generators: ChannelGenerators;
+  protected readonly computeModulator: (voice: Voice, pitchWheel: number, modulatorIndex: number) => number;
+  protected readonly computeModulators: (voice: Voice, sourceUsesCC?: 0 | 1 | -1 | undefined, sourceIndex?: number | undefined) => void;
   /**
-   * The master pan.
-   * From -1 (left) to 1 (right). 0 is center.
+   * Current amount of voices that are playing on this channel.
    */
-  pan: number;
+  protected _voiceCount: number;
   /**
-   * The global key shift in semitones.
-   * Drum channels ignore this value.
+   * Current amount of voices that are playing on this channel.
    */
-  keyShift: number;
+  get voiceCount(): number;
   /**
-   * The global tuning in cents.
-   * Drum channels ignore this value.
+   * Indicates whether this channel is a drum channel.
    */
-  fineTune: number;
+  protected _drumChannel: boolean;
   /**
-   * The interpolation type used for sample playback.
+   * Indicates whether this channel is a drum channel.
    */
-  interpolationType: InterpolationType;
+  get drumChannel(): boolean;
   /**
-   * If the synthesizer should prevent changing any parameters via NRPN.
+   * An array of MIDI controllers for the channel.
+   * This array is used to store the state of various MIDI controllers
+   * such as volume, pan, modulation, etc.
+   * @remarks
+   * A bit of an explanation:
+   * The controller table is stored as an int16 array, it stores 14-bit values, allowing for full 14-bit LSB resolution.
+   * The only exception from this are the Registered and Non-Registered Parameter Numbers.
+   * Data entries do store it!
    */
-  nrpnParamLock: boolean;
+  get midiControllers(): Readonly<Int16Array>;
   /**
-   * Indicates whether the synthesizer is in monophonic retrigger mode.
-   * This emulates the behavior of Microsoft GS Wavetable Synth,
-   * Where a new note will kill the previous one if it is still playing.
+   * The channel system parameters of this channel.
+   * These are only editable via the API.
    */
-  monophonicRetrigger: boolean;
-}
-declare const DEFAULT_GLOBAL_SYSTEM_PARAMETERS: GlobalSystemParameter;
-//#endregion
-//#region src/synthesizer/audio_engine/channel/awe32_nrpn.d.ts
-interface ChannelGenerators {
+  get systemParameters(): Readonly<ChannelSystemParameter>;
   /**
-   * An array of offsets generators for SF2 NRPN support.
-   * A value of 0 means no change; -10 means 10 lower, etc.
+   * The channel MIDI parameters of this channel.
+   * These are only editable via MIDI messages.
    */
-  offsets: Int16Array;
+  get midiParameters(): Readonly<ChannelMIDIParameter>;
+  protected get channelSystem(): MIDISystem;
   /**
-   * A small optimization that disables applying offsets until at least one is set.
+   * Locks or unlocks a given controller.
+   * This prevents any changes to it until it's unlocked.
+   * @param controller The MIDI controller number (0-127).
+   * @param isLocked If the controller should be locked.
    */
-  offsetsEnabled: boolean;
+  lockController(this: MIDIChannel, controller: MIDIController, isLocked: boolean): void;
   /**
-   * An array of overrides generators for AWE32 NRPN support.
-   * A value of GENERATOR_OVERRIDE_NO_CHANGE_VALUE (-32,767) means no change;
-   * other values replace current generators.
+   * 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.
    */
-  overrides: Int16Array;
+  setDrums(isDrum: boolean): void;
   /**
-   * A small optimization that disables applying overrides until at least one is set.
+   * Stops all notes on the channel.
+   * @param force If true, stops all notes immediately, otherwise applies release time.
    */
-  overridesEnabled: boolean;
+  stopAllNotes(force?: boolean): void;
+  protected resetGeneratorOverrides(): void;
+  protected setGeneratorOverride(gen: GeneratorType, value: number, realtime?: boolean): void;
+  protected resetGeneratorOffsets(): void;
+  protected setGeneratorOffset(gen: GeneratorType, value: number): void;
+  protected resetDrumParams(): void;
+  protected computeModulatorsAll(sourceUsesCC: -1 | 0 | 1, sourceIndex: number): void;
+  protected setBankMSB(bankMSB: number): void;
+  protected setBankLSB(bankLSB: number): void;
+  /**
+   * Sets drums on channel.
+   */
+  protected setDrumFlag(isDrum: boolean): void;
 }
 //#endregion
-//#region src/synthesizer/audio_engine/channel/parameters/system.d.ts
-/**
- * The system parameters of the channel.
- * These can only be changed via the API.
- */
-interface ChannelSystemParameter {
+//#region src/synthesizer/audio_engine/channel/parameters/midi.d.ts
+interface ChannelMIDIParameter {
   /**
-   * If the preset is locked, preventing any program changes from being sent.
+   * The current pressure (aftertouch) of this channel.
    */
-  presetLock: boolean;
+  pressure: number;
   /**
-   * If the channel should not produce any sound
-   * and ignore incoming Note On messages.
+   * The current pitch wheel value (0-16,383) of this channel.
    */
-  isMuted: boolean;
+  pitchWheel: number;
   /**
-   * The gain for the channel.
-   * From 0 to any number. 1 is 100% volume.
+   * The current pitch wheel range, in semitones.
    */
-  gain: number;
+  pitchWheelRange: number;
   /**
-   * The panning of the channel.
-   * -1 (left) to 1 (right). 0 is center.
+   * The modulation depth in cents.
+   * This is internally converted to a multiplier by dividing by 50.
+   *
+   * The MIDI specification assumes the default modulation depth is 50 cents,
+   * but it may vary for different sound banks.
+   * For example, if a MIDI requests 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.
    */
-  pan: number;
+  modulationDepth: number;
   /**
-   * The channel key shift in semitones.
-   * Drum channels DO NOT ignore this value.
+   * The channel's receiving number (0-based index).
+   * This allows triggering multiple parts (channels) with a single note message.
+   * @remarks
+   * Only used when customChannelNumbers is enabled.
+   */
+  rxChannel: number;
+  /**
+   * If the channel is in the poly mode.
+   * - `true` - POLY ON - regular playback.
+   * - `false` - MONO ON - one note per channel,
+   * highest still pressed note is restored after releasing the currently playing one.
+   */
+  polyMode: boolean;
+  /**
+   * The key shift of the channel (in semitones).
+   * Drum channels ignore this value.
    */
   keyShift: number;
   /**
-   * The channel tuning in cents.
-   * Drum channels DO NOT ignore this value.
+   * Cents, RPN/SysEx for fine-tuning.
+   * Drum channels ignore this value.
    */
   fineTune: number;
   /**
-   * The interpolation type used for sample playback.
+   * Enables random panning for every note played on this channel.
+   */
+  randomPan: boolean;
+  /**
+   * Assign mode for the channel.
+   * `ASSIGN MODE` is the parameter that determines how voice assignment will be handled when sounds overlap on identical note numbers in the same channel (i.e., repeatedly struck notes).
+   * This is initialized to a mode suitable for each Part, so for general purposes there is no need to change this.
    *
-   * Overrides the global parameter if set.
+   * - 0 - Single: If the same note is played multiple times in succession, the previously-sounding note will be completely silenced, and then the new note will be sounded.
+   * - 1 - LimitedMulti: If the same note is played multiple times in succession, the previously-sounding note will be continued to a certain extent even after the new note is sounded. (Default setting)
+   * - 2 - FullMulti: If the same note is played multiple times in succession, the previously-sounding note(s) will continue sounding for their natural length even after the new note is sounded.
+   *
+   * SpessaSynth treats LimitedMulti like FullMulti.
+   * Essentially Limited and Full are normal
+   * and Single is like `monophonicRetrigger` system parameter.
    */
-  interpolationType: InterpolationType | null;
+  assignMode: number;
   /**
-   * If the channel should prevent changing any parameters via NRPN.
+   * Indicates whether this channel uses the insertion EFX processor.
+   */
+  efxAssign: boolean;
+  /**
+   * CC1 for GS controller matrix.
+   * An arbitrary MIDI controller, which can be bound to any synthesis parameter.
+   * Default is 16.
+   */
+  cc1: MIDIController;
+  /**
+   * CC2 for GS controller matrix.
+   * An arbitrary MIDI controller, which can be bound to any synthesis parameter.
+   * Default is 17.
+   */
+  cc2: MIDIController;
+  /**
+   * Drum map for GS system exclusive tracking.
+   * Only used for selecting the correct channel when setting drum parameters through sysEx,
+   * as those don't specify the channel, but the drum number.
    *
-   * Overrides the global parameter if set.
+   * The only values that are allowed are 0 (melodic) 1 or 2.
    */
-  nrpnParamLock: boolean | null;
+  drumMap: number;
   /**
-   * Indicates whether the channel is in monophonic retrigger mode.
-   * This emulates the behavior of Microsoft GS Wavetable Synth,
-   * Where a new note will kill the previous one if it is still playing.
+   * The relation between the input and the actual velocity.
    *
-   * Overrides the global parameter if set.
+   * If Velo Depth is increased, small differences in your playing dynamics will make a large difference in the loudness of the sound.
+   * If Velo Depth is decreased, even large differences in your playing dynamics will make only a small difference in the loudness of the sound.
+   *
+   * Examples (with offset being set to normal):
+   *
+   * - 64 is normal.
+   * - 32 is half velocity at max volume.
+   * - 127 is max velocity at half volume.
+   *
+   * Refer to [SC-8850 Owner's Manual](https://cdn.roland.com/assets/media/pdf/SC-8850_OM.pdf), page 56.
    */
-  monophonicRetrigger: boolean | null;
+  velocitySenseDepth: number;
+  /**
+   * The offset to add to the input velocity.
+   *
+   * If Velo Offset is set higher than 64, even softly played notes (i.e., notes with a low velocity)
+   * will be sounded loudly. If Velo Offset is set lower than 64,
+   * even strongly played notes (i.e., notes with a high velocity) will be sounded softly.
+   *
+   * Examples (with depth set to normal):
+   *
+   * - 64 is normal.
+   * - 32 is silent until half velocity, max velocity is half volume.
+   * - 96 starts at half volume and reaches max volume at half velocity.
+   * - 127 always forces velocity to max.
+   *
+   * Refer to [SC-8850 Owner's Manual](https://cdn.roland.com/assets/media/pdf/SC-8850_OM.pdf), page 56.
+   */
+  velocitySenseOffset: number;
 }
-declare const DEFAULT_CHANNEL_SYSTEM_PARAMETERS: ChannelSystemParameter;
+declare const DEFAULT_CHANNEL_MIDI_PARAMETERS: ChannelMIDIParameter;
 /**
- * Sets a system parameter of the channel
- * @param parameter The type of the system parameter to set.
- * @param value The value to set for the system parameter.
+ * Locks or unlocks a given Channel MIDI Parameter.
+ * This prevents any changes to it until it's unlocked.
+ * @param parameter The Channel MIDI Parameter to lock.
+ * @param isLocked If the parameter should be locked.
  */
-declare function setSystemParameterInternal<P extends keyof ChannelSystemParameter>(this: MIDIChannel, parameter: P, value: ChannelSystemParameter[P]): void;
+declare function lockMIDIParameterInternal<P extends keyof ChannelMIDIParameter>(this: MIDIChannel, parameter: P, isLocked: boolean): void;
 //#endregion
-//#region src/synthesizer/audio_engine/channel/midi_channel.d.ts
-/**
- * This class represents a single MIDI Channel within the synthesizer.
- */
-declare class MIDIChannel {
+//#region src/synthesizer/audio_engine/channel/types.d.ts
+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 ProgramChangeCallback extends MIDIPatchFull {
+  /** The MIDI channel number. */
+  channel: number;
+}
+interface ControllerChangeCallback {
+  /** The MIDI channel number. */
+  channel: number;
+  /** The controller number. */
+  controller: MIDIController;
+  /** The value of the controller. */
+  value: number;
+}
+interface PolyPressureCallback {
+  /** The MIDI channel number. */
+  channel: number;
+  /** The MIDI note number. */
+  midiNote: number;
+  /** The pressure value. */
+  pressure: number;
+}
+interface StopAllCallback {
   /**
-   * 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.
+   * The MIDI channel number.
    */
-  readonly patch: MIDIPatch;
+  channel: number;
   /**
-   * The preset currently assigned to the channel.
-   * Note that this may be undefined in some cases.
+   * If the channel was force stopped. (no release time)
    */
-  preset?: BasicPreset;
+  force: boolean;
+}
+type ChannelMIDIParameterChange = { [P in keyof ChannelMIDIParameter]: {
   /**
-   * The channel's number (0-based index)
+   * The channel that was affected.
    */
-  readonly channel: number;
+  channel: number;
   /**
-   * Sets a system parameter of the channel.
-   * @param parameter The type of the system parameter to set.
-   * @param value The value to set for the system parameter.
+   * The parameter that was changed.
    */
-  readonly setSystemParameter: typeof setSystemParameterInternal;
+  parameter: P;
   /**
-   * An array of MIDI controllers for the channel.
-   * This array is used to store the state of various MIDI controllers
-   * such as volume, pan, modulation, etc.
-   * @remarks
-   * A bit of an explanation:
-   * The controller table is stored as an int16 array, it stores 14-bit values, allowing for full 14-bit LSB resolution.
-   * The only exception from this are the Registered and Non-Registered Parameter Numbers.
-   * Data entries do store it!
+   * The new value of this parameter.
+   */
+  value: ChannelMIDIParameter[P];
+} }[keyof ChannelMIDIParameter];
+//#endregion
+//#region src/synthesizer/audio_engine/parameters/system.d.ts
+/**
+ * The global parameters of the synthesizer.
+ * These can only be changed via the API.
+ */
+interface GlobalSystemParameter {
+  /**
+   * If the synthesizer processes the audio effects.
    */
-  protected readonly _midiControllers: Int16Array;
+  effectsEnabled: boolean;
   /**
-   * 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.
+   * If the event system is enabled.
    */
-  protected readonly octaveTuning: Int8Array;
-  protected readonly _midiParameters: Readonly<ChannelMIDIParameter>;
+  eventsEnabled: boolean;
   /**
-   * If the last Parameter was RPN.
-   * If false then the last parameter was NRPN.
-   * @protected
+   * The maximum number of voices that can be played at once.
+   *
+   * Increasing this value causes memory allocation for more voices.
+   * It is recommended to set it at the beginning, before rendering audio to avoid GC.
+   * Decreasing it does not cause memory usage change, so it's fine to use.
    */
-  protected lastParameterIsRegistered: boolean;
+  voiceCap: number;
   /**
-   * Per-note pitch wheel mode uses the pitchWheels table as source
-   * instead of the regular entry in the midiControllers table.
+   * Enabling this parameter will cause a new voice allocation when the voice cap is hit, rather than stealing existing voices.
+   *
+   * This is not recommended in real-time environments.
    */
-  protected perNotePitch: boolean;
+  autoAllocateVoices: boolean;
   /**
-   * Current pan in range [-500;500]
-   * Updated in `updateInternalParams`.
-   * This is used to avoid a big addition for every voice rendering call.
+   * The reverb effect gain.
+   * From 0 to any number. 1 is 100% reverb.
    */
-  protected currentPan: number;
+  reverbGain: number;
   /**
-   * Current tuning in cents.
-   * Updated in `updateInternalParams`.
-   * This is used to avoid a big addition for every voice rendering call.
+   * If the synthesizer should prevent editing of the reverb parameters.
+   * This effect is modified using MIDI system exclusive messages, so
+   * the recommended use case would be setting
+   * the reverb parameters then locking it to prevent changes by MIDI files.
    */
-  protected currentTuning: number;
+  reverbLock: boolean;
   /**
-   * Current key-shift.
-   * Updated in `updateInternalParams`.
+   * The chorus effect gain.
+   * From 0 to any number. 1 is 100% chorus.
    */
-  protected currentKeyShift: number;
+  chorusGain: number;
   /**
-   * Current gain.
-   * Updated in `updateInternalParams`.
-   * This is used to avoid a big multiplication for every voice rendering call.
+   * If the synthesizer should prevent editing of the chorus parameters.
+   * This effect is modified using MIDI system exclusive messages, so
+   * the recommended use case would be setting
+   * the chorus parameters then locking it to prevent changes by MIDI files.
    */
-  protected currentGain: number;
+  chorusLock: boolean;
   /**
-   * The last pressed note on this channel.
-   * -1 means none.
-   * This is not a `ChannelMIDIParameter` and is strictly internal,
-   * mostly because we don't want to send events for every note on message.
-   * It can be set with Portamento Control CC anyway.
-   * @protected
+   * The delay effect gain.
+   * From 0 to any number. 1 is 100% delay.
    */
-  protected lastNote: number;
+  delayGain: number;
   /**
-   * If the portamento should be executed once regardless of Portamento on/off.
-   * Adhering to the MIDI spec, CC#84 ignores on/off.
-   * This is also not a `ChannelMIDIParameter` for the same reason as `lastNote`
-   * @protected
+   * If the synthesizer should prevent editing of the delay parameters.
+   * This effect is modified using MIDI system exclusive messages, so
+   * the recommended use case would be setting
+   * the delay parameters then locking it to prevent changes by MIDI files.
    */
-  protected portamentoForce: boolean;
-  protected readonly generators: ChannelGenerators;
-  protected readonly computeModulator: (voice: Voice, pitchWheel: number, modulatorIndex: number) => number;
-  protected readonly computeModulators: (voice: Voice, sourceUsesCC?: 0 | 1 | -1 | undefined, sourceIndex?: number | undefined) => void;
+  delayLock: boolean;
   /**
-   * Current amount of voices that are playing on this channel.
+   * If the synthesizer should prevent changing the insertion effect type and parameters.
+   * This effect is modified using MIDI system exclusive messages, so
+   * the recommended use case would be setting
+   * the insertion effect type and parameters then locking it to prevent changes by MIDI files.
+   *
+   * To lock the channel insertion assign, lock the `efxAssign` parameter instead.
    */
-  protected _voiceCount: number;
+  insertionEffectLock: boolean;
   /**
-   * Current amount of voices that are playing on this channel.
+   * If the synthesizer should prevent editing of the drum parameters.
+   * These params are modified using MIDI system exclusive messages or NRPN, so
+   * the recommended use case would be setting
+   * the drum parameters then locking it to prevent changes by MIDI files.
    */
-  get voiceCount(): number;
+  drumLock: boolean;
   /**
-   * Indicates whether this channel is a drum channel.
+   * Forces note killing instead of releasing. Improves performance in black MIDIs.
    */
-  protected _drumChannel: boolean;
+  blackMIDIMode: boolean;
   /**
-   * Indicates whether this channel is a drum channel.
+   * Synthesizer's device ID for system exclusive messages. Set to -1 to accept all.
    */
-  get drumChannel(): boolean;
+  deviceID: number;
   /**
-   * An array of MIDI controllers for the channel.
-   * This array is used to store the state of various MIDI controllers
-   * such as volume, pan, modulation, etc.
-   * @remarks
-   * A bit of an explanation:
-   * The controller table is stored as an int16 array, it stores 14-bit values, allowing for full 14-bit LSB resolution.
-   * The only exception from this are the Registered and Non-Registered Parameter Numbers.
-   * Data entries do store it!
+   * The master gain.
+   * From 0 to any number. 1 is 100% volume.
    */
-  get midiControllers(): Readonly<Int16Array>;
+  gain: number;
   /**
-   * The channel system parameters of this channel.
-   * These are only editable via the API.
+   * The master pan.
+   * From -1 (left) to 1 (right). 0 is center.
    */
-  get systemParameters(): Readonly<ChannelSystemParameter>;
+  pan: number;
   /**
-   * The channel MIDI parameters of this channel.
-   * These are only editable via MIDI messages.
+   * The global key shift in semitones.
+   * Drum channels ignore this value.
    */
-  get midiParameters(): Readonly<ChannelMIDIParameter>;
-  protected get channelSystem(): MIDISystem;
+  keyShift: number;
   /**
-   * Locks or unlocks a given controller.
-   * This prevents any changes to it until it's unlocked.
-   * @param controller The MIDI controller number (0-127).
-   * @param isLocked If the controller should be locked.
+   * The global tuning in cents.
+   * Drum channels ignore this value.
    */
-  lockController(this: MIDIChannel, controller: MIDIController, isLocked: boolean): void;
+  fineTune: number;
   /**
-   * 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 interpolation type used for sample playback.
    */
-  setDrums(isDrum: boolean): void;
+  interpolationType: InterpolationType;
   /**
-   * Stops all notes on the channel.
-   * @param force If true, stops all notes immediately, otherwise applies release time.
+   * If the synthesizer should prevent changing any parameters via NRPN.
    */
-  stopAllNotes(force?: boolean): void;
-  protected resetGeneratorOverrides(): void;
-  protected setGeneratorOverride(gen: GeneratorType, value: number, realtime?: boolean): void;
-  protected resetGeneratorOffsets(): void;
-  protected setGeneratorOffset(gen: GeneratorType, value: number): void;
-  protected resetDrumParams(): void;
-  protected computeModulatorsAll(sourceUsesCC: -1 | 0 | 1, sourceIndex: number): void;
-  protected setBankMSB(bankMSB: number): void;
-  protected setBankLSB(bankLSB: number): void;
+  nrpnParamLock: boolean;
   /**
-   * Sets drums on channel.
+   * Indicates whether the synthesizer is in monophonic retrigger mode.
+   * This emulates the behavior of Microsoft GS Wavetable Synth,
+   * Where a new note will kill the previous one if it is still playing.
    */
-  protected setDrumFlag(isDrum: boolean): void;
+  monophonicRetrigger: boolean;
 }
+declare const DEFAULT_GLOBAL_SYSTEM_PARAMETERS: GlobalSystemParameter;
 //#endregion
 //#region src/synthesizer/audio_engine/sound_bank_manager.d.ts
 declare class SoundBankManager {
@@ -2449,12 +2527,13 @@ interface ChannelSnapshot {
   pitchWheels: Int16Array;
   generators: ChannelGenerators;
   midiParameters: ChannelMIDIParameter;
+  lockedMIDIParameters: Record<keyof ChannelMIDIParameter, boolean>;
   systemParameters: ChannelSystemParameter;
   octaveTuning: Int8Array;
   perNotePitch: boolean;
   drumParams: DrumParameterSnapshot[];
   drumChannel: boolean;
-  channelNumber: number;
+  channel: number;
 }
 //#endregion
 //#region src/synthesizer/audio_engine/synthesizer_snapshot.d.ts
@@ -2464,8 +2543,9 @@ interface SynthesizerSnapshot {
    * Key modifiers.
    */
   keyMappings: (KeyModifier | undefined)[][];
-  systemParameters: GlobalSystemParameter;
   midiParameters: GlobalMIDIParameter;
+  lockedMIDIParameters: Record<keyof GlobalMIDIParameter, boolean>;
+  systemParameters: GlobalSystemParameter;
   reverbProcessor: ReverbProcessorSnapshot;
   chorusProcessor: ChorusProcessorSnapshot;
   delayProcessor: DelayProcessorSnapshot;
@@ -2579,7 +2659,7 @@ declare class SpessaSynthProcessor {
    */
   private readonly synthCore;
   /**
-   * Tor applying the snapshot after an override sound bank too.
+   * For applying the snapshot after an override sound bank too.
    */
   private savedSnapshot?;
   /**
@@ -2638,12 +2718,19 @@ declare class SpessaSynthProcessor {
    * @returns If a BasicPreset instance is returned, it will be used by the channel.
    */
   onMissingPreset: (patch: MIDIPatch, system: MIDISystem) => BasicPreset | undefined;
+  /**
+   * Locks or unlocks a given Global MIDI Parameter.
+   * This prevents any changes to it until it's unlocked.
+   * @param parameter The Global MIDI Parameter to lock.
+   * @param isLocked If the parameter should be locked.
+   */
+  lockMIDIParameter<P extends keyof GlobalMIDIParameter>(parameter: P, isLocked: boolean): void;
   /**
    * Sets a system parameter of the synthesizer.
-   * @param type The type of the system parameter to set.
+   * @param parameter The type of the system parameter to set.
    * @param value The value to set for the system parameter.
    */
-  setSystemParameter<P extends keyof GlobalSystemParameter>(type: P, value: GlobalSystemParameter[P]): void;
+  setSystemParameter<P extends keyof GlobalSystemParameter>(parameter: P, value: GlobalSystemParameter[P]): void;
   /**
    * Executes a full synthesizer reset.
    * This will reset all controllers to their default values,
@@ -3070,6 +3157,11 @@ declare class Voice {
    * MIDI channel number of the voice.
    */
   channel: number;
+  /**
+   * Grouping voices for specific Note On messages.
+   * Used for overlapping Note Ons.
+   */
+  noteID: number;
   /**
    * MIDI note number of the voice.
    * Direct number from the Note On message and is
@@ -3183,7 +3275,7 @@ declare class Voice {
    * @param minNoteLength minimum note length in seconds
    */
   releaseVoice(currentTime: number, minNoteLength?: number): void;
-  setup(currentTime: number, channel: number, midiNote: number): void;
+  setup(currentTime: number, channel: number, midiNote: number, noteID: number): void;
 }
 //#endregion
 //#region src/soundbank/basic_soundbank/modulator_source.d.ts
@@ -3192,7 +3284,7 @@ declare class ModulatorSource {
    * 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
+   * If this field is set to true, the controller should 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.
    */
   isBipolar: boolean;
@@ -3706,6 +3798,50 @@ declare class MIDIMessage {
    * @param data the message's binary data.
    */
   constructor(ticks: number, byte: MIDIMessageType, data: Uint8Array<ArrayBuffer>);
+  /**
+   * Returns a new MIDI Pitch Wheel message.
+   * @param ticks time of this message in absolute MIDI ticks.
+   * @param channel the channel number of this message.
+   * @param value the new value, between 0 and 16383, where 8192 is the center (no pitch change).
+   */
+  static pitchWheel(ticks: number, channel: number, value: number): MIDIMessage;
+  /**
+   * Returns a new MIDI Channel Pressure message.
+   * @param ticks time of this message in absolute MIDI ticks.
+   * @param channel the channel number of this message.
+   * @param value the new value, between 0 and 127.
+   */
+  static channelPressure(ticks: number, channel: number, value: number): MIDIMessage;
+  /**
+   * Returns a new MIDI Program Change message.
+   * @param ticks time of this message in absolute MIDI ticks.
+   * @param channel the channel number of this message.
+   * @param program the new MIDI program number, between 0 and 127.
+   */
+  static programChange(ticks: number, channel: number, program: number): MIDIMessage;
+  /**
+   * Returns a new MIDI Controller Change message.
+   * @param ticks time of this message in absolute MIDI ticks.
+   * @param channel the channel number of this message.
+   * @param controller the MIDI controller.
+   * @param value the new value.
+   */
+  static controllerChange(ticks: number, channel: number, controller: MIDIController, value: number): MIDIMessage;
+  /**
+   * Returns a new MIDI System Exclusive message.
+   * @param ticks time of this message in absolute MIDI ticks.
+   * @param data the data of the system exclusive message,
+   * excluding the starting 0xF0 byte.
+   */
+  static systemExclusive(ticks: number, data: number[]): MIDIMessage;
+  /**
+   * Returns a new MIDI Registered Parameter message. Sends both data MSB and LSB.
+   * @param ticks time of this message in absolute MIDI ticks.
+   * @param channel the channel number of this message.
+   * @param parameter the 14-bit MIDI registered parameter number.
+   * @param value the 14-bit new value.
+   */
+  static registeredParameter(ticks: number, channel: number, parameter: number, value: number): MIDIMessage[];
 }
 //#endregion
 //#region src/midi/midi_tools/modify_midi.d.ts
@@ -3732,15 +3868,30 @@ interface ChannelModification {
    * - `MIDIPatch` - clear + sets the new patch according to the MIDI system at the start of the sequence.
    */
   patch?: ClearableParameter<MIDIPatch>;
+  /**
+   * The new MIDI parameters of this channel.
+   * - Key: the MIDI parameter name.
+   * - value:
+   *   - `"clear"` - all changes for this parameter are removed.
+   *   - `specific value` - clear + sets the new parameter at the start of the song, effectively locking them to the set value.
+   */
+  midiParams?: { [P in keyof ChannelMIDIParameter]?: ClearableParameter<ChannelMIDIParameter[P]> };
   /**
    * The channel key shift in semitones.
    * Note on/off numbers are shifted.
+   *
+   * This differs from the `keyShift` MIDI Parameter in that it shifts the actual note numbers,
+   * and doesn't delete or overwrite existing shifts.
    */
   keyShift?: number;
   /**
    * The channel tuning in cents.
    * Tuned using RPN Fine Tune.
    * Range is `[-100; 99.986]` cents.
+   *
+   * This differs from the `fineTune` MIDI Parameter
+   * in that it is relative to the tuning applied in the MIDI file,
+   * and it does not overwrite it.
    */
   fineTune?: number;
 }
@@ -3759,6 +3910,17 @@ interface ModifyMIDIOptions {
    * - `never` - not yet implemented.
    */
   drumSetupParams?: ClearableParameter<never>;
+  /**
+   * The global MIDI parameter changes.
+   * - Key: the MIDI parameter name.
+   * - value:
+   *   - `"clear"` - all changes for this parameter are removed.
+   *   - `specific value` - clear + sets the new parameter at the start of the song, effectively locking them to the set value.
+   *
+   * Please note that `"clear"` is not supported for the `system` parameter,
+   * as it may cause issues with the MIDI system detection and reset insertion.
+   */
+  midiParams?: { [P in keyof GlobalMIDIParameter]?: ClearableParameter<GlobalMIDIParameter[P]> };
   /**
    * The desired GS reverb parameters.
    * - `"clear"` - all existing parameter change MIDI messages are removed.
@@ -3947,7 +4109,7 @@ declare class BasicMIDI {
    * It supports Standard MIDI Files (SMF), RIFF MIDI (RMIDI), and Extensible Music Format (XMF).
    * It also handles embedded soundbanks in RMIDI files.
    * If the file is an RMIDI file, it will extract the embedded soundbank and store
-   * it in the `embeddedSoundFont` property of the BasicMIDI instance.
+   * it in the `embeddedSoundBank` property of the BasicMIDI instance.
    * If the file is an XMF file, it will parse the XMF structure and extract the MIDI data.
    */
   static fromArrayBuffer(arrayBuffer: ArrayBuffer, fileName?: string): BasicMIDI;
@@ -4026,7 +4188,9 @@ declare class BasicMIDI {
   modify(opts: Partial<ModifyMIDIOptions>): void;
   /**
    * Modifies the sequence *in-place* according to the locked presets and controllers in the given snapshot.
-   * Note that this ignores the MIDI parameters and only applies system parameter tuning.
+   *
+   * Note that System Parameters `fineTune` and `keyShift` are passed to the relative tuning parameters of the channels.
+   * Only locked MIDI parameters and controllers are applied.
    * @param snapshot the snapshot to apply.
    */
   applySnapshot(snapshot: SynthesizerSnapshot): void;
@@ -4197,19 +4361,28 @@ declare class MIDIBuilder extends BasicMIDI {
 }
 //#endregion
 //#region src/midi/midi_tools/midi_utils.d.ts
-type AnalyzedMIDIMessage = {
+type GlobalMIDIParameterMessage = { [P in keyof GlobalMIDIParameter]: {
+  type: "Global MIDI Param";
+  parameter: P;
+  value: GlobalMIDIParameter[P];
+} }[keyof GlobalMIDIParameter];
+type ChannelMIDIParameterMessage = { [P in keyof ChannelMIDIParameter]: {
+  type: "Channel MIDI Param";
+  parameter: P;
+  value: ChannelMIDIParameter[P];
+  channel: number;
+} }[keyof ChannelMIDIParameter];
+type AnalyzedParameter = {
   type: "Other";
 } | {
-  type: "XG Reset";
-} | {
-  type: "GM On";
-} | {
-  type: "GM Off";
-} | {
-  type: "GM2 On";
-} | {
-  type: "GS Reset";
-} | {
+  type: "Controller Change";
+  controller: MIDIController;
+  value: number;
+  channel: number;
+} | ChannelMIDIParameterMessage | {
+  type: "Drum Setup";
+};
+type AnalyzedMIDIMessage = AnalyzedParameter | {
   type: "Reverb Param";
 } | {
   type: "Chorus Param";
@@ -4223,32 +4396,13 @@ type AnalyzedMIDIMessage = {
   type: "Drums On";
   channel: number;
   isDrum: boolean;
-} | {
-  type: "Drum Setup";
 } | {
   type: "Program Change";
   channel: number;
   value: number;
 } | {
-  type: "Controller Change";
-  controller: MIDIController;
-  value: number;
-  channel: number;
-} | {
-  type: "Master Key Shift";
-  value: number;
-} | {
-  type: "Key Shift";
-  value: number;
-  channel: number;
-} | {
-  type: "Master Fine Tune";
-  value: number;
-} | {
-  type: "Fine Tune";
-  value: number;
-  channel: number;
-};
+  type: "Display Data";
+} | GlobalMIDIParameterMessage;
 /**
  * A general purpose class for handling MIDI messages.
  */
@@ -4266,7 +4420,7 @@ declare class MIDIUtils {
    * @param rpn The 14-bit RPN number.
    * @param value The 14-bit value for that number.
    */
-  static analyzeRPN(channel: number, rpn: number, value: number): AnalyzedMIDIMessage;
+  static analyzeRPN(channel: number, rpn: number, value: number): AnalyzedParameter;
   /**
    * Analyzes a MIDI Non-Registered Parameter Number
    * and returns an identification and data for it.
@@ -4274,7 +4428,27 @@ declare class MIDIUtils {
    * @param nrpn The 14-bit NRPN number.
    * @param value The 14-bit value for that number.
    */
-  static analyzeNRPN(channel: number, nrpn: number, value: number): AnalyzedMIDIMessage;
+  static analyzeNRPN(channel: number, nrpn: number, value: number): AnalyzedParameter;
+  /**
+   * Returns a list of MIDI events needed to set the given parameter.
+   * @param ticks The ticks for all events.
+   * @param system If the message has multiple ways of setting it,
+   * this selects the preferred way. Otherwise, it prefers Universal (GM).
+   * @param parameter The parameter to set.
+   * @param value The value to set it to.
+   */
+  static setGlobalMIDIParameter<P extends keyof GlobalMIDIParameter>(ticks: number, system: MIDISystem, parameter: P, value: GlobalMIDIParameter[P]): MIDIMessage[];
+  /**
+   * Returns a list of MIDI events needed to set the given parameter.
+   * @param ticks The ticks for all events.
+   * @param channel The channel number.
+   * @param system If the message has multiple ways of setting it,
+   * this selects the preferred way. Otherwise, it prefers Universal (GM).
+   * @param parameter The parameter to set.
+   * @param value The value to set it to.
+   * @returns The list of `MIDIMessage`s that set the parameter.
+   */
+  static setChannelMIDIParameter<P extends keyof ChannelMIDIParameter>(ticks: number, channel: number, system: MIDISystem, parameter: P, value: ChannelMIDIParameter[P]): MIDIMessage[];
   /**
    * Converts GS/XG "part number" to MIDI channel number.
    * @param part The part number.
@@ -4292,7 +4466,7 @@ declare class MIDIUtils {
    * @param a3 Address 3
    * @param data Data, can be multiple bytes.
    */
-  static gsData(a1: number, a2: number, a3: number, data: number[]): number[];
+  static gs(a1: number, a2: number, a3: number, data: number[]): number[];
   /**
    * Gets a GS System Exclusive MIDI message.
    * @param ticks The tick time of the message.
@@ -4303,18 +4477,41 @@ declare class MIDIUtils {
    */
   static gsMessage(ticks: number, a1: number, a2: number, a3: number, data: number[]): MIDIMessage;
   /**
-   * Gets a GS reset message System Exclusive MIDI message.
+   * Gets raw XG System Exclusive message bytes, without the 0xF0 status byte.
+   * @param a1 Address 1
+   * @param a2 Address 2
+   * @param a3 Address 3
+   * @param data Data, can be multiple bytes.
+   */
+  static xg(a1: number, a2: number, a3: number, data: number[]): number[];
+  /**
+   * Gets a XG System Exclusive MIDI message.
    * @param ticks The tick time of the message.
-   * @param channel The MIDI channel number.
-   * @param drumMap The drum map to use. 0 turns the channel into a melodic channel,
-   * while other values turn it into a drum channel.
+   * @param a1 Address 1
+   * @param a2 Address 2
+   * @param a3 Address 3
+   * @param data Data, can be multiple bytes.
+   */
+  static xgMessage(ticks: number, a1: number, a2: number, a3: number, data: number[]): MIDIMessage;
+  /**
+   * Gets a raw Device Control System Exclusive message bytes, without the 0xF0 status byte.
+   * @param subID The sub ID.
+   * @param data Data, can be multiple bytes.
+   */
+  static deviceControl(subID: number, data: number[]): number[];
+  /**
+   * Gets a Device Control System Exclusive MIDI message.
+   * @param ticks The tick time of the message.
+   * @param subID The sub ID.
+   * @param data Data, can be multiple bytes.
    */
-  static gsDrumChange(ticks: number, channel: number, drumMap: 0 | 1 | 2): MIDIMessage;
+  static deviceControlMessage(ticks: number, subID: number, data: number[]): MIDIMessage;
   /**
-   * Gets a GS reset message System Exclusive MIDI message.
+   * Gets a selected reset System Exclusive MIDI message.
    * @param ticks The tick time of the message.
+   * @param system The system to reset into.
    */
-  static gsReset(ticks: number): MIDIMessage;
+  static reset(ticks: number, system: MIDISystem): MIDIMessage;
   private static analyzeGM;
   private static analyzeXG;
   private static analyzeGS;