spessasynth_core 4.4.5 → 4.4.7

package/dist/index.d.ts

@@ -6,7 +6,7 @@
 export interface WaveWriteOptions {
   /**
    * If true, the gain of the entire song will be adjusted,
-   * so the max sample is always 32,767 or min is always -32,768 (whichever is greater). Recommended.
+   * so the loudest sample (by absolute value) becomes 32,767 or -32,767. Recommended.
    */
   normalizeAudio: boolean;
   /**
@@ -190,8 +190,9 @@ export declare class SpessaLog {
   /**
    * Enables or disables logging at various levels.
    * All the input variables are booleans corresponding to the things SpessaSynth logs.
-   * @param enableInfo enables info: all general info such as parsing sound banks, MIDI files, RPN changes, etc.
-   * @param enableWarn enables warning: all messages unrecognized by the synthesizer, other warnings.
+   * @param enableInfo enables info: all general info such as parsing sound banks, MIDI files, RPN changes,
+   * messages unrecognized by the synthesizer, etc.
+   * @param enableWarn enables warning: unexpected and erroneous behavior, such as invalid data or missing presets.
    * @param enableGroup enables groups: the groups for parsing the sound banks and MIDI files.
    */
   static setLogLevel(enableInfo: boolean, enableWarn: boolean, enableGroup: boolean): void;
@@ -425,7 +426,7 @@ export declare const ModulatorControllerSources: {
    */
   readonly pitchWheel: 14;
   /**
-   * The current pitch wheel range (where 1 means 127 semitones) on the channel.
+   * The current pitch wheel range (where 1 means 128 semitones) on the channel.
    */
   readonly pitchWheelRange: 16;
   /**
@@ -454,7 +455,7 @@ export declare const ModulatorCurveTypes: {
    */
   readonly concave: 1;
   /**
-   * Inverse of concave.
+   * Exponential ramp, the inverse of concave.
    */
   readonly convex: 2;
   /**
@@ -506,7 +507,7 @@ export declare class ModulatorSource {
   /**
    * 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.
+   * controller output, and the Key Number value of 127 corresponds to the minimum possible controller output.
    */
   isNegative: boolean;
   /**
@@ -787,12 +788,14 @@ export declare class MIDIPatchTools {
   /**
    * Converts a given {@link MIDIPatch} to a string.
    * The format is:
-   * - `DRUM:program` for `isGMGSDrum` set to `true`.
+   * - `DRUM:bankMSB:bankLSB:program` for `isGMGSDrum` set to `true`.
    * - `bankLSB:bankMSB:program` for `isGMGSDrum` set to `false`.
+   * @param patch The patch to convert.
    */
   static toMIDIString(patch: MIDIPatch): string;
   /**
    * Gets {@link MIDIPatch} from a given string.
+   * @param string The string in the {@link MIDIPatchTools.toMIDIString} format.
    */
   static fromMIDIString(string: string): MIDIPatch;
   /**
@@ -800,23 +803,30 @@ export declare class MIDIPatchTools {
    * The format is:
    * - `<MIDIPatch string> D <name>` for `isDrum` set to `true`.
    * - `<MIDIPatch string> M <name>` for `isDrum` set to `false`.
+   * @param patch The patch to convert.
    */
   static toFullMIDIString(patch: MIDIPatchFull): string;
   /**
    * Gets {@link MIDIPatchFull} from a given string.
+   * @param string The string in the {@link MIDIPatchTools.toFullMIDIString} format.
    */
   static fromFullMIDIString(string: string): MIDIPatchFull;
   /**
    * Checks if two MIDI patches represent the same one.
+   * @param patch1 The first patch.
+   * @param patch2 The second patch.
    */
   static matches(patch1: MIDIPatch, patch2: MIDIPatch): boolean;
   /**
    * A comparison function for `.sort()` or `.toSorted()`,
-   * ordering the patches in ascending order.
+   * ordering the patches in ascending order: by program, then bank MSB, then bank LSB, with GM/GS drums last.
+   * @param a The first patch.
+   * @param b The second patch.
    */
   static compare(a: MIDIPatch, b: MIDIPatch): number;
   /**
    * Checks if the given {@link MIDIPatchFull} is an XG/GM2 drum patch.
+   * @param p The patch to check.
    */
   static isXGDrum(p: MIDIPatchFull): boolean;
   /**
@@ -826,7 +836,7 @@ export declare class MIDIPatchTools {
    * @param patch The {@link MIDIPatch} to select.
    * @param system The MIDI system to select for.
    * @returns The selected patch.
-   * @throws Error An error if the array is empty,
+   * @throws Error An error if the array is empty.
    */
   static selectPatch<T extends MIDIPatchFull>(patches: T[], patch: MIDIPatch, system: MIDISystem): T;
   private static getAnyDrums;
@@ -956,7 +966,7 @@ export declare class BasicPreset implements MIDIPatchFull {
    * >
    * > Consider reading about [the DLS conversion problem](../../../docs/extra/dls-conversion-problem.md).
    *
-   * @returns The instrument containing the flattened zones. If flattening was successful, it should exactly the same as this preset.
+   * @returns The instrument containing the flattened zones. If flattening was successful, it should sound exactly the same as this preset.
    */
   toFlattenedInstrument(): BasicInstrument;
 }
@@ -964,9 +974,8 @@ export declare class BasicPreset implements MIDIPatchFull {
  * This module handles parsing and writing SoundFont2 (`.sf2`, `.sf3` and `.sfogg`) files.
  * It represents a single sound bank.
  *
- * It also contains support for `.dls` files and experimental read and write support for [64-bit SFE](https://github.com/SFe-Team-was-taken/SFE).
+ * It also contains support for `.dls` files and experimental read and write support for [64-bit SFE](https://sfe-team-was-taken.github.io/SFE/).
  *
-
  * **Specifications:**
  *
  * - [SoundFont2 Specification](http://www.synthfont.com/sfspec24.pdf)
@@ -1001,7 +1010,7 @@ export declare class BasicSoundBank {
    */
   soundBankInfo: SoundBankInfoData;
   /**
-   * An array of all presets in the bank, ordered by bank and preset number.
+   * An array of all presets in the bank, ordered by program and bank number, with GM/GS drum presets last.
    */
   presets: BasicPreset[];
   /**
@@ -1052,12 +1061,15 @@ export declare class BasicSoundBank {
    */
   static mergeSoundBanks(...soundBanks: BasicSoundBank[]): BasicSoundBank;
   /**
-   * Creates a simple sound bank with a single saw wave preset.
+   * Creates a simple SF2 file with a single saw wave preset.
    * Useful for testing synthesizer's functionality without providing a file.
+   * @returns The binary representation of the SF2 file.
    */
   static getSampleSoundBankFile(): ArrayBuffer;
   /**
-   * Copies a given sound bank, deeply cloning all presets instruments and samples.
+   * Copies a given sound bank, cloning all presets, instruments and samples.
+   * The sample data is shared with the original, not copied.
+   * Elements sharing a name are all copied, the repeats get a free name like `Piano-1`.
    * @param bank The sound bank to copy.
    */
   static copyFrom(bank: BasicSoundBank): BasicSoundBank;
@@ -1071,8 +1083,8 @@ export declare class BasicSoundBank {
    *
    * > **Warning**
    * >
-   * > Note that decompressing (sample format `pcm`) usually results
-   * > in permanent sample quality loss!
+   * > Note that compressing (sample format `compressed`) usually results
+   * > in permanent sample quality loss! Decompressing does not restore it.
    * > This method is memory and CPU intensive with large sound banks.
    *
    * @param options Options associated with setting the sample format.
@@ -1082,7 +1094,7 @@ export declare class BasicSoundBank {
   setSampleFormat(options: SetSampleFormatOptions): Promise<BasicSample[]>;
   /**
    * Writes out a DLS Level 2 sound bank. This may not be 100% accurate.
-   * Samples data is always written in the S16LE PCM encoding.
+   * Sample data is always written in the S16LE PCM encoding.
    *
    * > **Note**
    * >
@@ -1180,16 +1192,15 @@ export declare class BasicSoundBank {
   /**
    * Trims the sound bank _in-place_ to only contain samples in a given MIDI file.
    *
-
    * Absent presets will be removed from the sound bank,
    * and samples that don't get activated in the remaining presets will be removed as well.
    *
    * > **Note**
    * >
-   * > This exact type is returned from {@link BasicMIDI.getUsedProgramsAndKeys}
+   * > This exact type is returned from {@link BasicMIDI.getUsedProgramsAndKeys}.
    * > Consider reading the page for more explanation about the parameter.
    *
-   * @param presetData - A `Map`: `BasicPreset` -> `Set<"key-velocity">`.
+   * @param presetData A `Map`: `BasicPreset` -> `Map<MIDI note, Set<velocity>>`.
    * Absent presets will be removed from the sound bank,
    * and samples that don't get activated in the remaining presets will be removed as well.
    */
@@ -1438,7 +1449,7 @@ export declare class BasicSample {
    *
    * > **Warning**
    * >
-   * > Do not change this value directly. use {@link BasicSample.setSampleType},
+   * > Do not change this value directly. Use {@link BasicSample.setSampleType},
    * > {@link BasicSample.setLinkedSample} or {@link BasicSample.unlinkSample} instead.
    */
   sampleType: SampleType;
@@ -1500,7 +1511,7 @@ export declare class BasicSample {
    * @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 defines the sample type/compression.
+   * @param sampleType The sample's type, one of the {@link SampleTypes}.
    * @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. Exclusive.
    */
@@ -1700,7 +1711,7 @@ export declare const MIDIMessageTypes: {
  */
 type MIDIMessageType = (typeof MIDIMessageTypes)[keyof typeof MIDIMessageTypes];
 /**
- * All MIDI 1.0 controller values.
+ * All MIDI 1.0 controller numbers.
  *
  * > **Tip**
  * >
@@ -1757,10 +1768,10 @@ export declare const MIDIControllers: {
   readonly effectControl2LSB: 45;
   readonly undefinedCC14LSB: 46;
   readonly undefinedCC15LSB: 47;
-  readonly undefinedCC16LSB: 48;
-  readonly undefinedCC17LSB: 49;
-  readonly undefinedCC18LSB: 50;
-  readonly undefinedCC19LSB: 51;
+  readonly generalPurposeController1LSB: 48;
+  readonly generalPurposeController2LSB: 49;
+  readonly generalPurposeController3LSB: 50;
+  readonly generalPurposeController4LSB: 51;
   readonly undefinedCC20LSB: 52;
   readonly undefinedCC21LSB: 53;
   readonly undefinedCC22LSB: 54;
@@ -1811,32 +1822,120 @@ export declare const MIDIControllers: {
   readonly nonRegisteredParameterMSB: 99;
   readonly registeredParameterLSB: 100;
   readonly registeredParameterMSB: 101;
+  readonly undefinedCC102: 102;
+  readonly undefinedCC103: 103;
+  readonly undefinedCC104: 104;
+  readonly undefinedCC105: 105;
+  readonly undefinedCC106: 106;
+  readonly undefinedCC107: 107;
+  readonly undefinedCC108: 108;
+  readonly undefinedCC109: 109;
+  readonly undefinedCC110: 110;
+  readonly undefinedCC111: 111;
+  readonly undefinedCC112: 112;
+  readonly undefinedCC113: 113;
+  readonly undefinedCC114: 114;
+  readonly undefinedCC115: 115;
+  readonly undefinedCC116: 116;
+  readonly undefinedCC117: 117;
+  readonly undefinedCC118: 118;
+  readonly undefinedCC119: 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;
+  /**
+   * @deprecated Use {@link MIDIControllers.generalPurposeController1LSB} instead.
+   */
+  readonly undefinedCC16LSB: 48;
+  /**
+   * @deprecated Use {@link MIDIControllers.generalPurposeController2LSB} instead.
+   */
+  readonly undefinedCC17LSB: 49;
+  /**
+   * @deprecated Use {@link MIDIControllers.generalPurposeController3LSB} instead.
+   */
+  readonly undefinedCC18LSB: 50;
+  /**
+   * @deprecated Use {@link MIDIControllers.generalPurposeController4LSB} instead.
+   */
+  readonly undefinedCC19LSB: 51;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC102} instead.
+   */
   readonly undefinedCC102LSB: 102;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC103} instead.
+   */
   readonly undefinedCC103LSB: 103;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC104} instead.
+   */
   readonly undefinedCC104LSB: 104;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC105} instead.
+   */
   readonly undefinedCC105LSB: 105;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC106} instead.
+   */
   readonly undefinedCC106LSB: 106;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC107} instead.
+   */
   readonly undefinedCC107LSB: 107;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC108} instead.
+   */
   readonly undefinedCC108LSB: 108;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC109} instead.
+   */
   readonly undefinedCC109LSB: 109;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC110} instead.
+   */
   readonly undefinedCC110LSB: 110;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC111} instead.
+   */
   readonly undefinedCC111LSB: 111;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC112} instead.
+   */
   readonly undefinedCC112LSB: 112;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC113} instead.
+   */
   readonly undefinedCC113LSB: 113;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC114} instead.
+   */
   readonly undefinedCC114LSB: 114;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC115} instead.
+   */
   readonly undefinedCC115LSB: 115;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC116} instead.
+   */
   readonly undefinedCC116LSB: 116;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC117} instead.
+   */
   readonly undefinedCC117LSB: 117;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC118} instead.
+   */
   readonly undefinedCC118LSB: 118;
+  /**
+   * @deprecated Use {@link MIDIControllers.undefinedCC119} instead.
+   */
   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;
 };
 /**
  * @inheritDoc MIDIControllers
@@ -2057,7 +2156,8 @@ export interface VoiceParameters {
  * This function is used to compress/encode a {@link BasicSample}.
  * The function is recommended to be asynchronous.
  *
- *  > **Note**
+ * > **Note**
+ * >
  * > Using a custom function allows for using *any* type of compression for the SF3 soundBank.
  * > This is allowed by the [RFC describing SF3 spec](https://github.com/FluidSynth/fluidsynth/wiki/SoundFont3Format),
  * > but SpessaSynth can only read Ogg Vorbis compression.
@@ -2099,7 +2199,7 @@ export type SetSampleFormatOptions = {
    * - `pcm` - decompresses the sound bank and changes its version to `2.04` (SF2)
    * - `compressed` - compresses the sound bank with a given function and changes its version to `3.0` (SF3)
    *
-   * Note that decompressing usually results in permanent sample quality loss!
+   * Note that compressing usually results in permanent sample quality loss! Decompressing does not restore it.
    */
   format: "pcm";
 } | {
@@ -2108,7 +2208,7 @@ export type SetSampleFormatOptions = {
    * - `pcm` - decompresses the sound bank and changes its version to `2.04` (SF2)
    * - `compressed` - compresses the sound bank with a given function and changes its version to `3.0` (SF3)
    *
-   * Note that decompressing usually results in permanent sample quality loss!
+   * Note that compressing usually results in permanent sample quality loss! Decompressing does not restore it.
    */
   format: "compressed";
   /**
@@ -2129,7 +2229,7 @@ export interface SoundBankWriteOptions {
    */
   software: string;
   /**
-   * A function to allow showing progress long operations. It can be undefined.
+   * A function to allow showing progress of long operations. It can be undefined.
    */
   progressFunction?: ProgressFunction;
 }
@@ -2189,7 +2289,7 @@ export interface GenericRange {
  *   - Key: The MIDI note number.
  *   - Value: A set of all velocities this key was pressed with.
  *
- * @group MIDI.Protocol
+ * @group Sound Banks
  */
 export type PresetsWithKeyCombinations<T extends MIDIPatchFull> = Map<T, Map<number, Set<number>>>;
 /**
@@ -2291,9 +2391,28 @@ export declare const InterpolationTypes: {
    */
   readonly nearestNeighbor: 1;
   /**
-   * Slowest, high quality with little artifacting. (Default)
+   * Cubic Hermite interpolation. Good quality with little artifacting. (Default)
+   *
+   * Recommended for most use-cases.
    */
   readonly hermite: 2;
+  /**
+   * 32-point windowed sinc interpolation.
+   *
+   * Very high quality with almost no aliasing or harmonic distortion,
+   * usable in real time, but at a significantly higher CPU cost.
+   */
+  readonly sinc32: 3;
+  /**
+   * 128-point windowed sinc interpolation with antialiasing.
+   *
+   * The best quality, but extremely high cpu cost.
+   *
+   * > **Warning**
+   * >
+   * > This is very slow (especially for pitched up samples) and is meant for offline rendering, not real time playback.
+   */
+  readonly sinc128: 4;
 };
 /**
  * @inheritDoc InterpolationTypes
@@ -2401,7 +2520,9 @@ interface ChannelSystemParameter {
    */
   interpolationType: InterpolationType | null;
   /**
-   * If the channel should prevent changing any parameters via NRPN.
+   * If the channel should prevent changing the part parameters via NRPN (MSB 0x01).
+   * Drum, AWE32 and SF2 NRPNs are not affected.
+   * The vibrato NRPNs are only locked when they control the custom vibrato.
    *
    * Overrides the global parameter if set.
    */
@@ -2409,7 +2530,7 @@ interface ChannelSystemParameter {
   /**
    * 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.
+   * where a new note will kill the previous one on the same key if it is still playing.
    *
    * Overrides the global parameter if set.
    */
@@ -2625,7 +2746,7 @@ export interface GSChorusProcessor extends GSChorusParameter {
  */
 export interface GSDelayParameter extends GSSystemEffectParameter {
   /**
-   * 0-115
+   * 1-115
    * 0.1ms-340ms-1000ms
    * The delay effect has three delay times; center, left and
    * right (when listening in stereo). Delay Time Center sets the delay time of the delay
@@ -2634,7 +2755,7 @@ export interface GSDelayParameter extends GSSystemEffectParameter {
    */
   timeCenter: number;
   /**
-   * 0-120
+   * 1-120
    * 4% - 500%
    * This parameter sets the delay time of the delay located at the left as a percentage of
    * the Delay Time Center (up to a max. of 1.0 s).
@@ -2756,6 +2877,14 @@ export interface GSInsertionParameter {
    * Higher values result in more sound being sent.
    */
   sendLevelToDelay: number;
+  /**
+   * EFX send EQ switch: routes the insertion output through the equalizer (see {@link GSEqualizerProcessor})
+   * when on, or straight to the output when off.
+   * Default is `true` (on).
+   *
+   * In the SysEx message, `0` is off and any other value is on.
+   */
+  sendEQSwitch: boolean;
   /**
    * `0-127`
    *
@@ -2816,7 +2945,8 @@ export interface GSInsertionBlockSnapshot extends GSInsertionParameter {
 }
 /**
  * The Insertion effect (EFX) processes the parts (channels) that have EFX assigned
- * (see {@link ChannelMIDIParameter.efxAssign}) and is routed straight to the output.
+ * (see {@link ChannelMIDIParameter.efxAssign}) and is routed to the output,
+ * through the equalizer unless {@link GSInsertionParameter.sendEQSwitch} is off.
  * It can additionally send its output to the reverb, chorus and delay.
  *
  * This is a Roland GS-compatible insertion interface.
@@ -2841,7 +2971,7 @@ export interface GSInsertionBlock extends GSInsertionParameter {
   /**
    * Sets the EFX type of the block.
    *
-   * Type change resets the parameters and the send levels to their defaults.
+   * Type change resets the parameters, the send levels and the send EQ switch to their defaults.
    * The EFX control sources and depths are kept.
    * Behavior for unsupported types is up to the implementation.
    *
@@ -2894,6 +3024,93 @@ export interface GSInsertionBlock extends GSInsertionParameter {
    */
   applySnapshot(snapshot: GSInsertionBlockSnapshot): void;
 }
+/**
+ * GS-compatible equalizer parameters.
+ *
+ * Also see {@link GSEqualizerProcessor} to see how to implement a custom GS-compatible equalizer processor.
+ *
+ * @group Synthesizer.GS Effects
+ */
+export interface GSEqualizerParameter {
+  /**
+   * 0-1
+   * 200 Hz, 400 Hz
+   * This parameter sets the frequency of the low range shelf.
+   */
+  lowFrequency: number;
+  /**
+   * 52-76 (`0x34`-`0x4C`)
+   * -12 dB - 0 dB - +12 dB
+   * This parameter sets the amount of boost or cut for the low frequency range.
+   * 64 is 0 dB, each step is 1 dB.
+   */
+  lowGain: number;
+  /**
+   * 0-1
+   * 3 kHz, 6 kHz
+   * This parameter sets the frequency of the high range shelf.
+   */
+  highFrequency: number;
+  /**
+   * 52-76 (`0x34`-`0x4C`)
+   * -12 dB - 0 dB - +12 dB
+   * This parameter sets the amount of boost or cut for the high frequency range.
+   * 64 is 0 dB, each step is 1 dB.
+   */
+  highGain: number;
+}
+/**
+ * The equalizer is a two-band (low and high) shelving equalizer which boosts or cuts specified frequency
+ * ranges of the sound. An equalizer lets you
+ * boost or cut specified frequency ranges of a sound to adjust the tone. For each range,
+ * high and low, you can specify the frequency and the amount of boost or cut (gain).
+ *
+ * Only the parts with EQ enabled (see {@link ChannelMIDIParameter.eqEnabled}) pass through it,
+ * and the insertion effect passes through it when {@link GSInsertionParameter.sendEQSwitch} is on.
+ * The reverb, chorus and delay outputs do not.
+ *
+ * This is a Roland GS-compatible equalizer interface.
+ *
+ * It is used when {@link GlobalMIDIParameter.system} is `gm` `gm2` or `gs`.
+ *
+ * > **Note**
+ * >
+ * > The equalizer is disabled in XG mode.
+ *
+ * {@link SpessaSynthProcessor} allows you to supply a custom equalizer processor.
+ * A custom equalizer processor must implement this interface.
+ *
+ * ### Editing the parameters
+ *
+ * Editing the parameters can be done via GS system exclusive messages.
+ *
+ * > **Tip**
+ * >
+ * > Refer to [SC-8850 Owner's Manual](https://cdn.roland.com/assets/media/pdf/SC-8850_OM.pdf) (p.78, 86, 236) for more information.
+ *
+ * @group Synthesizer.GS Effects
+ */
+export interface GSEqualizerProcessor extends GSEqualizerParameter {
+  /**
+   * Process the effect and **adds** it to the output.
+   * @param inputLeft The left input buffer to process. It always starts at index 0.
+   * @param inputRight The right input buffer to process. It always starts at index 0.
+   * @param outputLeft The left output buffer.
+   * @param outputRight The right output buffer.
+   * @param startIndex The index to start mixing at into the output buffers.
+   * @param sampleCount The amount of samples to mix. This will never be larger than {@link SynthProcessorOptions.maxBufferSize} of the parent {@link SpessaSynthProcessor} instance.
+   */
+  process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, startIndex: number, sampleCount: number): void;
+  /**
+   * Gets a snapshot of this effect processor instance.
+   */
+  getSnapshot(): GSEqualizerParameter;
+  /**
+   * Restores this effect processor instance from a snapshot.
+   * @param snapshot The snapshot to restore.
+   */
+  applySnapshot(snapshot: GSEqualizerParameter): void;
+}
 /**
  * A snapshot of a {@link XGEffectBlock}.
  *
@@ -2918,7 +3135,7 @@ export interface XGEffectBlockSnapshot {
  *
  * It represents a single effect block.
  *
- * There are 4 effect blocks types in XG:
+ * There are 4 effect block types in XG:
  * - Reverb
  * - Chorus
  * - Variation
@@ -2998,7 +3215,14 @@ export interface XGSystemEffectBlockSnapshot extends XGSystemEffectParameter, XG
  * @group Synthesizer.XG Effects
  */
 export interface XGSystemEffectBlock extends XGEffectBlock, XGSystemEffectParameter {
+  /**
+   * Gets a snapshot of this XG effect block.
+   */
   getSnapshot(): XGSystemEffectBlockSnapshot;
+  /**
+   * Restores this XG effect block from a snapshot.
+   * @param snapshot The snapshot to restore.
+   */
   applySnapshot(snapshot: XGSystemEffectBlockSnapshot): void;
 }
 /**
@@ -3080,13 +3304,20 @@ export interface XGChorusBlock extends XGSystemEffectBlock, XGChorusParameter {
    * @param inputRight The input buffer to process. It always starts at index 0.
    * @param outputLeft The left output buffer.
    * @param outputRight The right output buffer.
-   * @param reverbLeft The left reverb send buffer.
-   * @param reverbRight The right reverb send buffer.
+   * @param reverbLeft The left reverb send buffer. It always starts at index 0.
+   * @param reverbRight The right reverb send buffer. It always starts at index 0.
    * @param startIndex The index to start mixing at into the output buffers.
    * @param sampleCount The amount of samples to mix. This will never be larger than {@link SynthProcessorOptions.maxBufferSize} of the parent {@link SpessaSynthProcessor} instance.
    */
   process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, reverbLeft: Float32Array, reverbRight: Float32Array, startIndex: number, sampleCount: number): void;
+  /**
+   * Gets a snapshot of this XG effect block.
+   */
   getSnapshot(): XGChorusBlockSnapshot;
+  /**
+   * Restores this XG effect block from a snapshot.
+   * @param snapshot The snapshot to restore.
+   */
   applySnapshot(snapshot: XGChorusBlockSnapshot): void;
 }
 /**
@@ -3098,7 +3329,7 @@ export interface XGInsertionParameter {
   /**
    * The channel routed through the insertion effect, 0-based.
    *
-   * 127 or a value that's above the current channel count means OFF.
+   * 127 or any value that's not below the current channel count means OFF.
    */
   partNumber: number;
 }
@@ -3143,7 +3374,14 @@ export interface XGInsertionBlock extends XGInsertionParameter, XGEffectBlock {
    * @param sampleCount The amount of samples to mix. This will never be larger than {@link SynthProcessorOptions.maxBufferSize} of the parent {@link SpessaSynthProcessor} instance.
    */
   processInsertion(inputLeft: Float32Array, inputRight: Float32Array, sampleCount: number): void;
+  /**
+   * Gets a snapshot of this XG effect block.
+   */
   getSnapshot(): XGInsertionBlockSnapshot;
+  /**
+   * Restores this XG effect block from a snapshot.
+   * @param snapshot The snapshot to restore.
+   */
   applySnapshot(snapshot: XGInsertionBlockSnapshot): void;
 }
 /**
@@ -3156,7 +3394,7 @@ export interface XGVariationParameter extends XGSystemEffectParameter, XGInserti
    * Indicates if variation is in the insertion mode (CONNECTION).
    * If `false`, then variation is in the `system` mode.
    *
-   * The two connection modes work as following:
+   * The two connection modes work as follows:
    * - `system` routes all channels via sends (like reverb and chorus).
    * - `insertion` routes a single `partNumber` channel straight through. Note that variation is processed last, after all insertion effects.
    */
@@ -3232,7 +3470,14 @@ export interface XGVariationBlock extends XGVariationParameter, XGSystemEffectBl
    * @param sampleCount The amount of samples to mix. This will never be larger than {@link SynthProcessorOptions.maxBufferSize} of the parent {@link SpessaSynthProcessor} instance.
    */
   process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, chorusLeft: Float32Array, chorusRight: Float32Array, reverbLeft: Float32Array, reverbRight: Float32Array, startIndex: number, sampleCount: number): void;
+  /**
+   * Gets a snapshot of this XG effect block.
+   */
   getSnapshot(): XGVariationBlockSnapshot;
+  /**
+   * Restores this XG effect block from a snapshot.
+   * @param snapshot The snapshot to restore.
+   */
   applySnapshot(snapshot: XGVariationBlockSnapshot): void;
 }
 /**
@@ -3283,7 +3528,7 @@ interface GlobalSystemParameter {
    * The reverb effect gain.
    * From 0 to any number. 1 is 100% reverb.
    *
-   * Applies to both GS and XG reverb.
+   * Applies to both GS and XG reverb, including XG parts with an insertion effect assigned.
    */
   reverbGain: number;
   /**
@@ -3304,7 +3549,7 @@ interface GlobalSystemParameter {
    * The chorus effect gain.
    * From 0 to any number. 1 is 100% chorus.
    *
-   * Applies to both GS and XG chorus.
+   * Applies to both GS and XG chorus, including XG parts with an insertion effect assigned.
    */
   chorusGain: number;
   /**
@@ -3333,6 +3578,17 @@ interface GlobalSystemParameter {
    * the delay parameters then locking it to prevent changes by MIDI files.
    */
   gsDelayLock: boolean;
+  /**
+   * If the synthesizer should prevent editing of the GS equalizer parameters.
+   * This effect is modified using MIDI system exclusive messages, so
+   * the recommended use case would be setting
+   * the equalizer parameters then locking it to prevent changes by MIDI files.
+   *
+   * > **Warning**
+   * >
+   * > To lock the channel equalizer switch, lock the {@link ChannelMIDIParameter.eqEnabled `eqEnabled`} parameter instead.
+   */
+  gsEqualizerLock: boolean;
   /**
    * The XG variation gain when in system mode. {@link XGVariationConnection}
    * From 0 to any number. 1 is 100% variation.
@@ -3432,7 +3688,11 @@ interface GlobalSystemParameter {
    */
   interpolationType: InterpolationType;
   /**
-   * If the synthesizer should prevent changing any parameters via NRPN.
+   * If the synthesizer should prevent changing the part parameters via NRPN (MSB 0x01).
+   * Drum, AWE32 and SF2 NRPNs are not affected.
+   * The vibrato NRPNs are only locked when they control the custom vibrato.
+   *
+   * Channels can override it with {@link ChannelSystemParameter.nrpnParamLock}.
    */
   nrpnParamLock: boolean;
   /**
@@ -3781,6 +4041,10 @@ interface SynthesizerSnapshot {
    * A snapshot of the delay processor.
    */
   gsDelayProcessor: GSDelayParameter;
+  /**
+   * A snapshot of the equalizer processor.
+   */
+  gsEqualizerProcessor: GSEqualizerParameter;
   /**
    * A snapshot of the GS insertion block.
    */
@@ -3918,6 +4182,11 @@ export declare class SpessaSynthProcessor {
    * Current total amount of voices that are playing.
    */
   get voiceCount(): number;
+  /**
+   * The decoded sample data kept under {@link SynthProcessorOptions.decodedSampleBudget}, in bytes.
+   * It is only counted when a budget is set.
+   */
+  get decodedSampleBytes(): number;
   /**
    * Locks or unlocks a given {@link GlobalMIDIParameter}.
    * This prevents any changes to it until it's unlocked.
@@ -3948,7 +4217,7 @@ export declare class SpessaSynthProcessor {
    * > Refer to the [MIDI Implementation](../../docs/extra/midi-implementation.md)
    * > for the list of supported System Exclusives.
    *
-   * @param syx The system exclusive message as an array of bytes.
+   * @param syx The system exclusive message as an array of bytes, without the starting `F0` byte.
    * @param channelOffset The channel offset for the message as they usually can only address the first 16 channels.
    * For example, to send a system exclusive on channel 16,
    * send a system exclusive for channel 0 and set an offset of 16.
@@ -4039,11 +4308,11 @@ export declare class SpessaSynthProcessor {
    */
   processMessages(messages: (SysExAcceptedArray | MIDIMessage)[], channelOffset?: number, options?: SynthMethodOptions): void;
   /**
-   *  Destroy the synthesizer processor, clearing all channels and voices.
+   * Destroy the synthesizer processor, clearing all channels and voices.
    *
-   *  > **Warning**
-   *  >
-   *  > This is irreversible, so use with caution.
+   * > **Warning**
+   * >
+   * > This is irreversible, so use with caution.
    */
   destroy(): void;
   /**
@@ -4053,6 +4322,9 @@ export declare class SpessaSynthProcessor {
    * >
    * > This method overrides the existing System Parameters with the ones from the snapshot.
    *
+   * If this processor has more XG insertion blocks than the snapshot,
+   * the blocks without snapshot data are reset to their defaults.
+   *
    * @param snapshot The snapshot to apply.
    */
   applySnapshot(snapshot: SynthesizerSnapshot): void;
@@ -4113,11 +4385,6 @@ export declare class SpessaSynthProcessor {
    * > For edits inside existing presets, {@link clearCache} is enough.
    */
   refreshPresets(): void;
-  /**
-   * The decoded sample data kept under {@link SynthProcessorOptions.decodedSampleBudget}, in bytes.
-   * It is only counted when a budget is set.
-   */
-  get decodedSampleBytes(): number;
   /**
    * Clears the synthesizer's voice cache.
    * This can be used to hear the changes after editing a {@link BasicSoundBank}
@@ -4258,7 +4525,7 @@ export type ChannelMIDIParameterMessage = { [P in keyof ChannelMIDIParameter]: {
   channel: number;
 }; }[keyof ChannelMIDIParameter];
 /**
- * Represents an analyzed channel GS Reverb Processor change.
+ * Represents an analyzed GS Reverb Processor change.
  *
  * @group MIDI.Protocol
  */
@@ -4290,7 +4557,7 @@ export type GSReverbParameterMessage = { [P in keyof GSReverbParameter]: {
   value: number;
 };
 /**
- * Represents an analyzed channel GS Chorus Processor change.
+ * Represents an analyzed GS Chorus Processor change.
  *
  * @group MIDI.Protocol
  */
@@ -4322,7 +4589,7 @@ export type GSChorusParameterMessage = { [P in keyof GSChorusParameter]: {
   value: number;
 };
 /**
- * Represents an analyzed channel GS Delay Processor change.
+ * Represents an analyzed GS Delay Processor change.
  *
  * @group MIDI.Protocol
  */
@@ -4354,7 +4621,26 @@ export type GSDelayParameterMessage = { [P in keyof GSDelayParameter]: {
   value: number;
 };
 /**
- * Represents an analyzed channel GS Insertion Processor change.
+ * Represents an analyzed GS Equalizer Processor change.
+ *
+ * @group MIDI.Protocol
+ */
+export type GSEqualizerParameterMessage = { [P in keyof GSEqualizerParameter]: {
+  /**
+   * The message type identifier.
+   */
+  type: "GS Equalizer Param";
+  /**
+   * The GS equalizer parameter being modified.
+   */
+  parameter: P;
+  /**
+   * The new value of the GS equalizer parameter.
+   */
+  value: GSEqualizerParameter[P];
+}; }[keyof GSEqualizerParameter];
+/**
+ * Represents an analyzed GS Insertion Processor change.
  *
  * @group MIDI.Protocol
  */
@@ -4379,11 +4665,24 @@ export type GSInsertionParameterMessage = {
   /**
    * The parameter name that was modified in the processor: a send level or an EFX control setting.
    */
-  parameter: keyof GSInsertionParameter;
+  parameter: Exclude<keyof GSInsertionParameter, "sendEQSwitch">;
   /**
    * The new value of the parameter.
    */
   value: number;
+} | {
+  /**
+   * An insertion effect processor parameter message (Roland GS).
+   */
+  type: "GS Insertion Param";
+  /**
+   * The send EQ switch, see {@link GSInsertionParameter.sendEQSwitch}.
+   */
+  parameter: "sendEQSwitch";
+  /**
+   * If the insertion output goes through the equalizer.
+   */
+  value: boolean;
 } | {
   /**
    * An insertion effect processor parameter message (Roland GS).
@@ -4728,7 +5027,7 @@ export type AnalyzedParameter = {
  *
  * @group MIDI.Protocol
  */
-export type AnalyzedMIDIMessage = AnalyzedParameter | GSReverbParameterMessage | GSChorusParameterMessage | GSDelayParameterMessage | GSInsertionParameterMessage | XGReverbParameterMessage | XGChorusParameterMessage | XGVariationParameterMessage | XGInsertionParameterMessage | {
+export type AnalyzedMIDIMessage = AnalyzedParameter | GSReverbParameterMessage | GSChorusParameterMessage | GSDelayParameterMessage | GSEqualizerParameterMessage | GSInsertionParameterMessage | XGReverbParameterMessage | XGChorusParameterMessage | XGVariationParameterMessage | XGInsertionParameterMessage | {
   /**
    * A MIDI program change message configured via System Exclusive.
    */
@@ -4869,7 +5168,7 @@ export interface ControllerChangeEvent extends ChannelEvent {
 }
 /**
  * This event is triggered when a MIDI polyphonic pressure event is received. This controls the pressure of a single note.
- * By default, this controls vibrato in SpessaSynth, though it can be changed with sound bank modulators.
+ * It has no effect by default, it has to be assigned with sound bank modulators or system exclusives.
  *
  * @group Synthesizer.Events
  */
@@ -4955,6 +5254,7 @@ export type FXType<K> = Exclude<keyof K, "process" | "getSnapshot" | "applySnaps
  * - {@link GSReverbProcessor} (`effect: "gsReverb"`)
  * - {@link GSChorusProcessor} (`effect: "gsChorus"`)
  * - {@link GSDelayProcessor} (`effect: "gsDelay"`)
+ * - {@link GSEqualizerProcessor} (`effect: "gsEqualizer"`)
  * - {@link GSInsertionBlock} (`effect: "gsInsertion"`)
  * - {@link XGReverbBlock} (`effect: "xgReverb"`)
  * - {@link XGChorusBlock} (`effect: "xgChorus"`)
@@ -5003,6 +5303,19 @@ export type EffectChangeEvent = {
    * The new 7-bit value.
    */
   value: number;
+} | {
+  /**
+   * The effect that was changed: Roland GS equalizer.
+   */
+  effect: "gsEqualizer";
+  /**
+   * The parameter, see {@link GSEqualizerParameter}.
+   */
+  parameter: keyof GSEqualizerParameter;
+  /**
+   * The new 7-bit value.
+   */
+  value: number;
 } | {
   /**
    * The effect that was changed: Roland GS insertion.
@@ -5015,11 +5328,24 @@ export type EffectChangeEvent = {
    * - `"controlSource1" | "controlDepth1" | "controlSource2" | "controlDepth2"` - EFX control (7-bit), see {@link GSInsertionParameter}.
    * - `number` - 0-based type-specific EFX parameter index (0-19). EFX parameter 1 is 0. Value is 7-bit.
    */
-  parameter: "type" | keyof GSInsertionParameter | number;
+  parameter: "type" | Exclude<keyof GSInsertionParameter, "sendEQSwitch"> | number;
   /**
    * The new value for the parameter.
    */
   value: number;
+} | {
+  /**
+   * The effect that was changed: Roland GS insertion.
+   */
+  effect: "gsInsertion";
+  /**
+   * The send EQ switch, see {@link GSInsertionParameter.sendEQSwitch}.
+   */
+  parameter: "sendEQSwitch";
+  /**
+   * If the insertion output goes through the equalizer.
+   */
+  value: boolean;
 } | {
   /**
    * The effect that was changed: Yamaha XG reverb block.
@@ -5145,12 +5471,11 @@ export type UserDrumSetChangeEvent = { [P in keyof UserDrumSetParameter]: {
  * | `noteOff`            | {@link NoteOffEvent}                      | Key has been released.                          |
  * | `controllerChange`   | {@link ControllerChangeEvent}             | Controller has been changed.                    |
  * | `programChange`      | {@link ProgramChangeEvent}                | Program has been changed.                       |
- * | `channelPressure`    | —                                         | Channel's pressure has been changed.            |
- * | `polyPressure`       | {@link PolyPressureEvent}                 | Note's pressure has been changed.               |
+ * | `polyPressure`       | {@link PolyPressureEvent}                | Note's pressure has been changed.               |
  * | `stopAll`            | {@link StopAllEvent}                      | All voices were stopped on a given channel.     |
  * | `channelAdded`       | —                                         | A new channel was added to the synth.           |
  * | `presetListChange`   | —                                         | The preset list has been changed/initialized.   |
- * | `reset`              | —                                         | The synthesizer has been reset.                 |
+ * | `reset`              | —                                         | The synthesizer is about to be reset.           |
  * | `displayMessage`     | —                                         | The synthesizer has received a display message. |
  * | `globalParamChange`  | {@link GlobalMIDIParameterChangeEvent}    | A global MIDI Parameter has been changed.       |
  * | `channelParamChange` | {@link ChannelMIDIParameterChangeEvent}   | A channel MIDI Parameter has been changed.      |
@@ -5163,6 +5488,11 @@ export type UserDrumSetChangeEvent = { [P in keyof UserDrumSetParameter]: {
  * > It automatically combines the sound banks and sends the list of presets as they will be played.
  * > It also signals that the sound bank has been fully loaded.
  *
+ * > **Note**
+ * >
+ * > There is no separate channel pressure event.
+ * > Channel pressure changes are reported as `channelParamChange` with the `pressure` parameter.
+ *
  * @group Synthesizer.Events
  */
 export interface SynthesizerEvent {
@@ -5176,7 +5506,7 @@ export interface SynthesizerEvent {
   noteOff: NoteOffEvent;
   /**
    * This event is triggered when a controller is changed on any channel (usually MIDI controller change),
-   * though  [some system exclusives can change it too.](../../docs/extra/midi-implementation.md)
+   * though [some system exclusives can change it too.](../../docs/extra/midi-implementation.md)
    *
    * > **Note**
    * >
@@ -5195,7 +5525,7 @@ export interface SynthesizerEvent {
   programChange: ProgramChangeEvent;
   /**
    * This event is triggered when a MIDI polyphonic pressure event is received. This controls the pressure of a single note.
-   * By default, this controls vibrato in SpessaSynth, though it can be changed with sound bank modulators.
+   * It has no effect by default, it has to be assigned with sound bank modulators or system exclusives.
    */
   polyPressure: PolyPressureEvent;
   /**
@@ -5228,9 +5558,10 @@ export interface SynthesizerEvent {
    */
   presetListChange: MIDIPatchFull[];
   /**
-   * This event is triggered when all controllers and programs have been reset. Effectively a system reset.
+   * This event is triggered when the synthesizer is about to be reset (all controllers and programs). Effectively a system reset.
+   * It is called before anything is reset, so the synthesizer still has its old state at that point.
    *
-   * The data is the new system the synthesizer was reset with.
+   * The data is the new system the synthesizer will be reset to.
    *
    * > **Note**
    * >
@@ -5244,9 +5575,10 @@ export interface SynthesizerEvent {
    *
    * Notable messages that can trigger this event:
    *
-   * - All messages with GS Model ID of `0x45` (Display Data)
+   * - GS Display Data (Model ID `0x45`) messages with the first address byte `0x10` or `0x20`
    * - GS Patch Name
    * - GS Drum Map Name
+   * - GS User Drum Set Name
    * - XG Display Letter
    * - XG Display Bitmap
    *
@@ -5361,6 +5693,8 @@ interface DefaultXGEffectProcessorConstructor {
 export declare abstract class DefaultXGEffect implements XGEffectBlock {
   /**
    * The currently used processor.
+   * Hidden from the docs as the processor types are internal.
+   * @hidden
    */
   protected processor: DefaultXGEffectProcessor;
   protected readonly outputLeft: Float32Array<ArrayBuffer>;
@@ -5380,8 +5714,9 @@ export declare abstract class DefaultXGEffect implements XGEffectBlock {
    * @param defaultType The default effect type.
    * @param sampleRate The sample rate, in Hertz.
    * @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-   * Attempting to `.process()` more samples than this will result in an error.
+   * Processing more samples than this is not supported and produces undefined output.
    * @param variation True for the variation and insertion blocks.
+   * @hidden
    */
   protected constructor(effectMap: Map<number, DefaultXGEffectProcessorConstructor>, fallbackProcessor: DefaultXGEffectProcessorConstructor, defaultType: number, sampleRate: number, maxBufferSize: number, variation: boolean);
   setType(type: number): void;
@@ -5404,8 +5739,18 @@ export declare abstract class DefaultXGEffect implements XGEffectBlock {
 export declare abstract class DefaultXGSystemEffect extends DefaultXGEffect implements XGSystemEffectBlock {
   return: number;
   pan: number;
+  /**
+   * Resets this block to default values, including the processor type.
+   */
   reset(): void;
+  /**
+   * Gets a snapshot of this XG effect block.
+   */
   getSnapshot(): XGSystemEffectBlockSnapshot;
+  /**
+   * Restores this XG effect block from a snapshot.
+   * @param snapshot The snapshot to restore.
+   */
   applySnapshot(snapshot: XGSystemEffectBlockSnapshot): void;
   /**
    * Mixes the staged wet output into the system effect destination, applying return and pan.
@@ -5419,6 +5764,8 @@ export declare abstract class DefaultXGSystemEffect extends DefaultXGEffect impl
 /**
  * The default implementation for {@link XGReverbBlock}.
  *
+ * The default type is HALL 1. Unknown types use the type with LSB 0, or NO EFFECT (silence) if that is missing too.
+ *
  * @group Synthesizer.XG Effects
  * @sealed
  */
@@ -5427,7 +5774,7 @@ export declare class DefaultXGReverb extends DefaultXGSystemEffect implements XG
    * Constructs a new default XG reverb processor.
    * @param sampleRate The sample rate, in Hertz.
    * @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-   * Attempting to `.process()` more samples than this will result in an error.
+   * Processing more samples than this is not supported and produces undefined output.
    */
   constructor(sampleRate: number, maxBufferSize: number);
   process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, startIndex: number, sampleCount: number): void;
@@ -5435,6 +5782,8 @@ export declare class DefaultXGReverb extends DefaultXGSystemEffect implements XG
 /**
  * The default implementation for {@link XGChorusBlock}.
  *
+ * The default type is CHORUS 1. Unknown types use the type with LSB 0, or NO EFFECT (silence) if that is missing too.
+ *
  * @group Synthesizer.XG Effects
  * @sealed
  */
@@ -5444,11 +5793,17 @@ export declare class DefaultXGChorus extends DefaultXGSystemEffect implements XG
    * Constructs a new default XG chorus processor.
    * @param sampleRate The sample rate, in Hertz.
    * @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-   * Attempting to `.process()` more samples than this will result in an error.
+   * Processing more samples than this is not supported and produces undefined output.
    */
   constructor(sampleRate: number, maxBufferSize: number);
+  /**
+   * Resets this block to default values, including the processor type.
+   */
   reset(): void;
   process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, reverbLeft: Float32Array, reverbRight: Float32Array, startIndex: number, sampleCount: number): void;
+  /**
+   * Gets a snapshot of this XG effect block.
+   */
   getSnapshot(): {
     sendToReverb: number;
     return: number;
@@ -5456,11 +5811,18 @@ export declare class DefaultXGChorus extends DefaultXGSystemEffect implements XG
     type: number;
     params: Int16Array;
   };
+  /**
+   * Restores this XG effect block from a snapshot.
+   * @param snapshot The snapshot to restore.
+   */
   applySnapshot(snapshot: XGChorusBlockSnapshot): void;
 }
 /**
  * The default implementation for {@link XGVariationBlock}.
  *
+ * The default type is DELAY L,C,R in the insertion connection.
+ * Unknown types use the type with LSB 0, or THRU if that is missing too.
+ *
  * @group Synthesizer.XG Effects
  * @sealed
  */
@@ -5473,12 +5835,18 @@ export declare class DefaultXGVariation extends DefaultXGSystemEffect implements
    * Constructs a new default XG variation processor.
    * @param sampleRate The sample rate, in Hertz.
    * @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-   * Attempting to `.process()` more samples than this will result in an error.
+   * Processing more samples than this is not supported and produces undefined output.
    */
   constructor(sampleRate: number, maxBufferSize: number);
+  /**
+   * Resets this block to default values, including the processor type.
+   */
   reset(): void;
   process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, chorusLeft: Float32Array, chorusRight: Float32Array, reverbLeft: Float32Array, reverbRight: Float32Array, startIndex: number, sampleCount: number): void;
   processInsertion(inputLeft: Float32Array, inputRight: Float32Array, sampleCount: number): void;
+  /**
+   * Gets a snapshot of this XG effect block.
+   */
   getSnapshot(): {
     insertionMode: boolean;
     partNumber: number;
@@ -5489,11 +5857,19 @@ export declare class DefaultXGVariation extends DefaultXGSystemEffect implements
     type: number;
     params: Int16Array;
   };
+  /**
+   * Restores this XG effect block from a snapshot.
+   * @param snapshot The snapshot to restore.
+   */
   applySnapshot(snapshot: XGVariationBlockSnapshot): void;
 }
 /**
  * The default implementation for {@link XGInsertionBlock}.
  *
+ * The default type is DISTORTION. The EFFECT 2 types run on the same processors as the variation block types.
+ * The early reflection types and PHASER 2 are variation only, so PHASER 2 falls back to PHASER 1 here.
+ * Unknown types use the type with LSB 0, or THRU if that is missing too.
+ *
  * @group Synthesizer.XG Effects
  * @sealed
  */
@@ -5503,16 +5879,26 @@ export declare class DefaultXGInsertion extends DefaultXGEffect implements XGIns
    * Constructs a new default XG insertion processor.
    * @param sampleRate The sample rate, in Hertz.
    * @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-   * Attempting to `.process()` more samples than this will result in an error.
+   * Processing more samples than this is not supported and produces undefined output.
    */
   constructor(sampleRate: number, maxBufferSize: number);
+  /**
+   * Resets this block to default values, including the processor type.
+   */
   reset(): void;
   processInsertion(inputLeft: Float32Array, inputRight: Float32Array, sampleCount: number): void;
+  /**
+   * Gets a snapshot of this XG effect block.
+   */
   getSnapshot(): {
     partNumber: number;
     type: number;
     params: Int16Array<ArrayBufferLike>;
   };
+  /**
+   * Restores this XG effect block from a snapshot.
+   * @param snapshot The snapshot to restore.
+   */
   applySnapshot(snapshot: XGInsertionBlockSnapshot): void;
 }
 /**
@@ -5532,7 +5918,8 @@ export interface SoundBankManagerListEntry {
   soundBank: BasicSoundBank;
   /**
    * The bank MSB offset for this sound bank.
-   * This value will be added to all {@link BasicPreset.bankMSB} fields when resolving the preset list.
+   * This value will be added to all {@link BasicPreset.bankMSB} fields when resolving the preset list,
+   * except for the XG drum banks (120 and 127). The result is capped at 127.
    */
   bankOffset: number;
 }
@@ -5603,6 +5990,10 @@ export interface SynthProcessorOptions {
    * Optional custom GS delay processor for the synthesizer. Leave undefined to use {@link DefaultGSDelay}.
    */
   gsDelayProcessor?: GSDelayProcessor;
+  /**
+   * Optional custom GS equalizer processor for the synthesizer. Leave undefined to use {@link DefaultGSEqualizer}.
+   */
+  gsEqualizerProcessor?: GSEqualizerProcessor;
   /**
    * Optional custom GS insertion block for the synthesizer. Leave undefined to use {@link DefaultGSInsertion}.
    */
@@ -5686,11 +6077,6 @@ export declare class MIDIChannel {
    * The channel's number (0-based index).
    */
   readonly channel: number;
-  /**
-   * If true, this skips sends as they all go through insertion.
-   * Set by {@link SpessaSynthProcessor}.
-   */
-  xgInsertionAssigned: boolean;
   /**
    * Current amount of voices that are playing on this channel.
    */
@@ -5852,7 +6238,7 @@ interface ChannelMIDIParameter {
   randomPan: boolean;
   /**
    * Assign mode for the channel:
-   * - `0` - A new note will kill the previous one if it is still playing.
+   * - `0` - A new note will kill the previous one on the same key if it is still playing.
    * - Any other value - A new note will not kill the previous notes (default).
    *
    * While GS and XG differentiate 1 (Limited Multi for GS/Multi for XG) and 2 (Full Multi for GS/Inst (for Drum)),
@@ -5870,6 +6256,16 @@ interface ChannelMIDIParameter {
    * Indicates whether this channel uses the GS insertion EFX processor.
    */
   efxAssign: boolean;
+  /**
+   * Indicates whether this channel passes through the GS equalizer (see {@link GSEqualizerProcessor}).
+   * Default is `true`, like on the Sound Canvas.
+   *
+   * > **Note**
+   * >
+   * > Channels with {@link efxAssign} enabled ignore this.
+   * > Their equalizer routing is set by {@link GSInsertionParameter.sendEQSwitch} instead.
+   */
+  eqEnabled: boolean;
   /**
    * CC1 for GS controller matrix.
    * An arbitrary MIDI controller, which can be bound to any synthesis parameter.
@@ -6115,7 +6511,7 @@ interface ModifyMIDIOptions {
    * > **Note**
    * >
    * > By default, a meaningful GM reset (one with notes after it)
-   * > is replaced with a GS reset. Set the `system` parameter to `gm`
+   * > is replaced with a GS reset (or `fallbackReset`, if set). Set the `system` parameter to `gm`
    * > to keep the GM reset (and replace all others with GM).
    * > This is done to allow the bank selections and other parameters to work.
    */
@@ -6138,6 +6534,12 @@ interface ModifyMIDIOptions {
    * - {@link GSDelayParameter} - clear + the new parameters are set via System Exclusive messages.
    */
   gsDelayParams?: ClearableParameter<GSDelayParameter>;
+  /**
+   * The GS equalizer parameters.
+   * - `"clear"` - all existing parameter change MIDI messages are cleared.
+   * - {@link GSEqualizerParameter} - clear + the new parameters are set via System Exclusive messages.
+   */
+  gsEqualizerParams?: ClearableParameter<GSEqualizerParameter>;
   /**
    * The GS Insertion Effect parameters.
    * - `"clear"` - all existing parameter change MIDI messages are cleared.
@@ -6175,8 +6577,9 @@ interface ModifyMIDIOptions {
   /**
    * The system reset to add when the file contains no reset.
    * Unlike `midiParams.system`, existing resets are left untouched.
-   * Ignored when `midiParams.system` is set (it takes precedence)
-   * and when `midiParams.system` is `"clear"` (no reset is added).
+   * Ignored when `midiParams.system` is set (it takes precedence).
+   * When `midiParams.system` is `"clear"`, no reset is added,
+   * but this still selects the system the setup messages are written for.
    * When unset, the added reset defaults to `"xg"`
    * if only XG setups are requested, otherwise to `"gs"`.
    *
@@ -6224,7 +6627,7 @@ export interface RMIDInfoData {
   creationDate: Date;
   /**
    * The copyright string.
-   * If not provided, `Created with SpessaSynth` is used.
+   * If not provided, `Created using SpessaSynth` is used.
    */
   copyright: string;
   /**
@@ -6238,6 +6641,7 @@ export interface RMIDInfoData {
   midiEncoding: string;
   /**
    * The software used to write the file.
+   * If not provided, `SpessaSynth` is used.
    */
   software: string;
   /**
@@ -6246,6 +6650,8 @@ export interface RMIDInfoData {
   subject: string;
 }
 /**
+ * A single tempo change in a MIDI sequence.
+ *
  * @group MIDI.Sequence
  */
 export interface TempoChange {
@@ -6279,7 +6685,7 @@ export interface MIDILoop {
    * 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.
+   * Soft loop types are enabled for Touhou loop points (CC 2 and CC 4) and RPG Maker loop points (CC 111).
    */
   type: "soft" | "hard";
 }
@@ -6293,7 +6699,9 @@ export interface MIDILoop {
  */
 export type MIDIFormat = 0 | 1 | 2;
 /**
- *  @group MIDI.Sequence
+ * A single note's time and velocity, as returned by {@link BasicMIDI.getNoteTimes}.
+ *
+ * @group MIDI.Sequence
  */
 export interface NoteTime {
   /**
@@ -6330,8 +6738,10 @@ export interface RMIDIWriteOptions {
    *
    * > **Warning**
    * >
-   * > Providing *any* of the metadata fields overrides the info encoding with `utf-8`.
+   * > Writing always sets the info encoding to `utf-8`,
+   * > since the default fields (such as the creation date) are always written.
    * > This behavior is forced due to lack of support for other encodings by the `TextEncoder` class.
+   * > Existing info chunks in another encoding (see {@link BasicMIDI.infoEncoding}) are re-encoded to UTF-8.
    *
    */
   metadata: Partial<Omit<RMIDInfoData, "infoEncoding">>;
@@ -6343,7 +6753,7 @@ export interface RMIDIWriteOptions {
   /**
    * The sound bank instance that `soundBankBinary` contains.
    * Used for correcting bank and program changes when `correctBankOffset` is enabled.
-   * If omitted, bank correction may be less accurate.
+   * If it is omitted, the correction is skipped and a warning is logged.
    */
   soundBank?: BasicSoundBank;
 }
@@ -6354,6 +6764,8 @@ export interface RMIDIWriteOptions {
  */
 export type RMIDInfoFourCC = "INAM" | "IPRD" | "IALB" | "IART" | "IGNR" | "IPIC" | "ICOP" | "ICRD" | "ICRT" | "ICMT" | "IENG" | "ISFT" | "ISBJ" | "IENC" | "MENC" | "DBNK";
 /**
+ * A reference to an event in {@link BasicMIDI.timeline}, pointing at its track and its index in that track.
+ *
  * @group MIDI.Sequence
  */
 export interface TimelineEvent {
@@ -6517,7 +6929,7 @@ export declare class MIDITrack {
    */
   port: number;
   /**
-   * A set that contains the MIDI channel numbers used by this track.
+   * A set that contains the MIDI channel numbers (0-15) that have note on events in this track.
    */
   channels: Set<number>;
   /**
@@ -6537,7 +6949,7 @@ export declare class MIDITrack {
   copyFrom(track: MIDITrack): void;
   /**
    * Adds events to the track.
-   * @param index The index at which to add these event.
+   * @param index The index at which to add these events.
    * @param events The events to add.
    */
   addEvents(index: number, ...events: MIDIMessage[]): void;
@@ -6666,7 +7078,8 @@ export declare class BasicMIDI {
    * The loop points (in ticks) of the sequence, including both start and end points.
    *
    * If there's nothing detected, the loop will start from the first note on event and end will be the last voice message.
-   * Current looping detection is: CC 2/4, 116/117 and "start," "loopStart" and "loopEnd" markers.
+   * Current looping detection is: CC 2/4 (Touhou), CC 111 (RPG Maker), CC 116/117 and 118/119 (EMIDI/XMI)
+   * and the "start", "loopStart" and "loopEnd" markers.
    */
   loop: MIDILoop;
   /**
@@ -6680,6 +7093,7 @@ export declare class BasicMIDI {
   format: MIDIFormat;
   /**
    * The RMID (Resource-Interchangeable MIDI) info data, if the file is RMID formatted.
+   * XMF metadata and converted tracker modules are stored here as well.
    * Otherwise, this object is empty.
    * Info type: Chunk data as a binary array.
    *
@@ -6745,7 +7159,7 @@ export declare class BasicMIDI {
    * This function reads the MIDI file format, extracts the header and track chunks,
    * and populates the BasicMIDI instance with the parsed data.
    * It supports Standard MIDI Files (SMF), RIFF MIDI (RMIDI), and Extensible Music Format (XMF).
-   * It also handles embedded soundbanks in RMIDI files.
+   * It also handles embedded soundbanks in RMIDI and XMF files.
    * Tracker modules (ProTracker MOD, Fast Tracker 2 XM, Scream Tracker 3 S3M) are converted
    * into MIDI with an embedded sound bank.
    */
@@ -6762,7 +7176,7 @@ export declare class BasicMIDI {
    */
   static copyFrom(mid: BasicMIDI): BasicMIDI;
   /**
-   * Copies another instance this `BasicMIDI` instance, including track data.
+   * Copies another instance into this `BasicMIDI` instance, including track data.
    * @param mid The MIDI to copy.
    */
   copyFrom(mid: BasicMIDI): void;
@@ -6794,7 +7208,7 @@ export declare class BasicMIDI {
   getUsedProgramsAndKeys<T extends MIDIPatchFull>(soundbank: CallableSoundBank<T>): PresetsWithKeyCombinations<T>;
   /**
    * Preloads all voices for this sequence in a given {@link SpessaSynthProcessor}.
-   * This caches all the needed voices for playing back this sequencer, resulting in a smooth playback.
+   * This caches all the needed voices for playing back this sequence, resulting in a smooth playback.
    * The sequencer calls this function by default when loading the songs. (it can be disabled: {@link SpessaSynthSequencer.preload}).
    * @param synth The synthesizer to preload.
    */
@@ -6813,6 +7227,12 @@ export declare class BasicMIDI {
   flush(sortEvents?: boolean): void;
   /**
    * Calculates all note times in seconds.
+   *
+   * > **Note**
+   * >
+   * > MIDI ports are ignored, so the channels of every port are merged into the 16 channels.
+   * > For example, channel 1 of port 2 is returned as channel 1.
+   *
    * @param minDrumLength In seconds, represents the minimum allowed time for a drum note,
    *   since they sometimes have a length of 0.
    * @returns An array of 16 channels, each channel containing its notes,
@@ -6861,7 +7281,7 @@ export declare class BasicMIDI {
    */
   writeMIDI(): ArrayBuffer;
   /**
-   * Writes out an RMIDI file (MIDI + SF2).
+   * Writes out an RMIDI file (MIDI + SF2 or DLS).
    * [See more info about this format](https://github.com/spessasus/sf2-rmidi-specification#readme).
    *
    * Note that this method modifies the MIDI file in-place.
@@ -6870,11 +7290,16 @@ export declare class BasicMIDI {
    * The method is called on a `BasicMIDI` instance;
    * that instance is the MIDI file to embed.
    *
+   * > **Warning**
+   * >
+   * > Do not call in audioWorkletGlobalScope as it uses TextDecoder and TextEncoder.
+   * > Bank offset correction (on by default) needs `soundBank`. Without it, the correction is skipped with a warning.
+   *
    * > **Tip**
    * >
    * > Use {@link BasicSoundBank.trim} to drastically reduce the file size.
-   * > consider also using compression (like shown in example) to save even more space.
-   * > (using these both methods, I managed to shrink a 1GB sound bank into a 5MB RMIDI!)
+   * > Consider also using compression (like shown in example) to save even more space.
+   * > (using both of these methods, I managed to shrink a 1GB sound bank into a 5MB RMIDI!)
    *
    * @param soundBankBinary The binary sound bank (SF2 or DLS) to embed into the file.
    * @param configuration Extra options for writing the file.
@@ -6912,7 +7337,7 @@ export declare class BasicMIDI {
    *
    *     // trim the soundfont
    *     soundBank.trim(midi.getUsedProgramsAndKeys(soundBank));
-   *     // write out with compression to save space (0.5 is medium quality)
+   *     // write out with compression to save space
    *     await soundBank.setSampleFormat({
    *         format: "compressed",
    *         compressionFunction: SampleEncodingFunction // Remember to get your compression function
@@ -6948,6 +7373,8 @@ export declare class BasicMIDI {
    * and inserts/deletes messages appropriately.
    *
    * This modifies the MIDI sequence _in-place_.
+   *
+   * @param opts The modifications to apply.
    */
   modify(opts: Partial<ModifyMIDIOptions>): void;
   /**
@@ -6955,8 +7382,10 @@ export declare class BasicMIDI {
    * This means changing the programs and controllers if they are locked.
    *
    * For example, if channel 1 has locked preset on `Drawbar Organ`,
-   * this will remove all program changes for channel 1 and add one at the start to change the program to
+   * this will remove all program changes for channel 1 and add one before the channel's first note on
+   * (and again after every system reset) to change the program to
    * `Drawbar organ` (using bank MSB/LSB and program change).
+   * Muted channels are removed from the sequence.
    *
    * > **Warning**
    * >
@@ -7002,6 +7431,12 @@ export declare class BasicMIDI {
    * > **Note**
    * >
    * > This sets the Info encoding to `utf-8`.
+   * > Text chunks that are already present get re-encoded from their old encoding (IENC) to UTF-8,
+   * > so they stay readable. Without IENC, they are assumed to be UTF-8 already, like {@link BasicMIDI.getRMIDInfo} does.
+   *
+   * > **Warning**
+   * >
+   * > Do not call in audioWorkletGlobalScope as it uses TextDecoder and TextEncoder.
    *
    * @param infoType The type to set.
    * @param infoData The value to set it to.
@@ -7009,6 +7444,11 @@ export declare class BasicMIDI {
   setRMIDInfo<K extends keyof RMIDInfoData>(infoType: K, infoData: RMIDInfoData[K]): void;
   /**
    * Gets a given chunk from the RMIDI information.
+   *
+   * > **Warning**
+   * >
+   * > Do not call in audioWorkletGlobalScope as it uses TextDecoder.
+   *
    * @param infoType The metadata type.
    * @returns `string`, `Date`, `ArrayBuffer` or undefined if the info is not set.
    */
@@ -7022,7 +7462,7 @@ export declare class BasicMIDI {
    * > if you are not editing the MIDI file in your loop.
    * > It is usually a faster solution and allows custom loops.
    *
-   *     If the track data is being edited, remember to call {@link BasicMIDI.flush} it after editing!
+   * If the track data is being edited, remember to call {@link BasicMIDI.flush} after editing!
    *
    * @param callback The callback function to process each event.
    */
@@ -7056,11 +7496,13 @@ export interface MIDIBuilderOptions {
   /**
    * The MIDI file track format.
    * Format 0 allows only one track while format 1 allows more than one.
-   * Format 2 is very rare and should not be used.
+   * Format 2 is very rare and is not supported by the builder (an error is thrown).
+   * Defaults to 0.
    */
   format: MIDIFormat;
   /**
    * The MIDI file's name. Will be appended to the conductor (first) track and encoded with UTF-8.
+   * Defaults to `Untitled song`.
    */
   name: string;
 }
@@ -7075,6 +7517,7 @@ export interface MIDIBuilderOptions {
  * > **Warning**
  * >
  * > Remember to call {@link BasicMIDI.flush} after you're done building the file!
+ * > Do not use in audioWorkletGlobalScope as it uses TextEncoder.
  *
  * @group MIDI.Files
  */
@@ -7218,7 +7661,7 @@ export declare class MIDIUtils {
    * @param channel The MIDI channel number.
    * @param rpn The 14-bit RPN number.
    * @param value The 14-bit value for that number.
-   * @returns The analysis result(s) of the message.
+   * @returns The analysis result of the message.
    */
   static analyzeRPN(channel: number, rpn: number, value: number): AnalyzedParameter;
   /**
@@ -7229,7 +7672,7 @@ export declare class MIDIUtils {
    * @param value The 14-bit value for that number.
    * @param drumPitchStep The drum pitch coarse resolution in semitones.
    * 0.5 for GS (SC-88 and above), 1 for XG and the SC-55 drum map (bank LSB 1).
-   * @returns The analysis result(s) of the message.
+   * @returns The analysis result of the message.
    */
   static analyzeNRPN(channel: number, nrpn: number, value: number, drumPitchStep?: number): AnalyzedParameter;
   /**
@@ -7262,15 +7705,23 @@ export declare class MIDIUtils {
   static setGSDelayParameter<P extends GSDelayParameterMessage["parameter"]>(ticks: number, parameter: P, value: Extract<GSDelayParameterMessage, {
     parameter: P;
   }>["value"]): MIDIMessage;
+  /**
+   * Returns a MIDI event needed to set the given GS Equalizer Parameter.
+   * @param ticks The MIDI tick time for the output event.
+   * @param parameter The parameter to set.
+   * @param value The value to set it to.
+   * @returns The {@link MIDIMessage} needed to set this GS Equalizer Parameter.
+   */
+  static setGSEqualizerParameter(ticks: number, parameter: GSEqualizerParameterMessage["parameter"], value: number): MIDIMessage;
   /**
    * Returns a MIDI event needed to set the given GS Insertion Parameter.
    * @param ticks The MIDI tick time for the output event.
    * @param parameter The parameter to set: `"type"`, a send level or EFX control name (see {@link GSInsertionParameter}),
    * or a 0-based effect-specific parameter number (0-19).
-   * @param value The value to set it to.
+   * @param value The value to set it to. A boolean for `"sendEQSwitch"`.
    * @returns The {@link MIDIMessage} needed to set this GS Insertion Parameter.
    */
-  static setGSInsertionParameter(ticks: number, parameter: GSInsertionParameterMessage["parameter"], value: number): MIDIMessage;
+  static setGSInsertionParameter(ticks: number, parameter: GSInsertionParameterMessage["parameter"], value: number | boolean): MIDIMessage;
   /**
    * Returns a MIDI event needed to set the given XG Reverb Parameter.
    * @param ticks The MIDI tick time for the output event.
@@ -7493,7 +7944,7 @@ export declare class DrumParameterUtils {
    */
   static copyInto(source: DrumParameter, dest: DrumParameter): void;
   /**
-   * Checks if this user drum parameter is the default.
+   * Checks if this drum parameter is the default.
    * @param param the param to check.
    * @param midiNote the MIDI note of this parameter.
    */
@@ -7551,7 +8002,11 @@ export interface SequencerEvent {
     newTime: number;
   };
   /**
-   * This event is called when the playback stops.
+   * This event is called when the song finishes and the playback stops.
+   * It is not called when pausing manually.
+   *
+   * With more than one song in the list, the sequencer moves on to the next song instead,
+   * so this event is not called.
    */
   songEnded: object;
   /**
@@ -7559,7 +8014,8 @@ export interface SequencerEvent {
    */
   songChange: {
     /**
-     * The index of the new song in {@link SpessaSynthSequencer.songs}.
+     * The new {@link SpessaSynthSequencer.songIndex}.
+     * If shuffle mode is enabled, this is the index in the shuffled song list, not in {@link SpessaSynthSequencer.songs}.
      */
     songIndex: number;
   };
@@ -7865,7 +8321,7 @@ export declare class DefaultGSReverb implements GSReverbProcessor {
    * Constructs a new default GS reverb processor.
    * @param sampleRate The sample rate, in Hertz.
    * @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-   * Attempting to `.process()` more samples than this will result in an error.
+   * Processing more samples than this is not supported and produces undefined output.
    */
   constructor(sampleRate: number, maxBufferSize: number);
   private _delayFeedback;
@@ -7887,12 +8343,12 @@ export declare class DefaultGSReverb implements GSReverbProcessor {
   get preLowpass(): number;
   set preLowpass(value: number);
   /**
-   *
-   * @param input 0-based
-   * @param outputLeft startIndex-based
-   * @param outputRight startIndex-based
-   * @param startIndex
-   * @param sampleCount
+   * Process the effect and **adds** it to the output.
+   * @param input The input buffer to process. It always starts at index 0.
+   * @param outputLeft The left output buffer.
+   * @param outputRight The right output buffer.
+   * @param startIndex The index to start mixing at into the output buffers.
+   * @param sampleCount The amount of samples to mix.
    */
   process(input: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, startIndex: number, sampleCount: number): void;
   getSnapshot(): GSReverbParameter;
@@ -7939,7 +8395,7 @@ export declare class DefaultGSChorus implements GSChorusProcessor {
    * Constructs a new default GS chorus processor.
    * @param sampleRate The sample rate, in Hertz.
    * @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-   * Attempting to `.process()` more samples than this will result in an error.
+   * Processing more samples than this is not supported and produces undefined output.
    */
   constructor(sampleRate: number, maxBufferSize: number);
   private _sendLevelToReverb;
@@ -8019,7 +8475,7 @@ export declare class DefaultGSDelay implements GSDelayProcessor {
    * Constructs a new default GS delay processor.
    * @param sampleRate The sample rate, in Hertz.
    * @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-   * Attempting to `.process()` more samples than this will result in an error.
+   * Processing more samples than this is not supported and produces undefined output.
    */
   constructor(sampleRate: number, maxBufferSize: number);
   private _sendLevelToReverb;
@@ -8067,6 +8523,47 @@ export declare class DefaultGSDelay implements GSDelayProcessor {
   private updateDelayTimes;
   private updateGain;
 }
+/**
+ * The default GS Equalizer implementation for {@link SpessaSynthProcessor}.
+ *
+ * @group Synthesizer.GS Effects
+ */
+export declare class DefaultGSEqualizer implements GSEqualizerProcessor {
+  private readonly sampleRate;
+  private lowB0;
+  private lowB1;
+  private lowA1;
+  private highB0;
+  private highB1;
+  private highA1;
+  private lowZL;
+  private lowZR;
+  private highZL;
+  private highZR;
+  /**
+   * Constructs a new default GS equalizer processor.
+   * @param sampleRate The sample rate, in Hertz.
+   */
+  constructor(sampleRate: number);
+  private _lowFrequency;
+  get lowFrequency(): number;
+  set lowFrequency(value: number);
+  private _lowGain;
+  get lowGain(): number;
+  set lowGain(value: number);
+  private _highFrequency;
+  get highFrequency(): number;
+  set highFrequency(value: number);
+  private _highGain;
+  get highGain(): number;
+  set highGain(value: number);
+  process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, startIndex: number, sampleCount: number): void;
+  getSnapshot(): GSEqualizerParameter;
+  applySnapshot(snapshot: GSEqualizerParameter): void;
+  private getBand;
+  private updateLow;
+  private updateHigh;
+}
 /**
  * The default implementation for {@link GSInsertionBlock}.
  *
@@ -8077,6 +8574,7 @@ export declare class DefaultGSInsertion implements GSInsertionBlock {
   sendLevelToReverb: number;
   sendLevelToChorus: number;
   sendLevelToDelay: number;
+  sendEQSwitch: boolean;
   controlSource1: number;
   controlDepth1: number;
   controlSource2: number;
@@ -8119,7 +8617,7 @@ export declare class DefaultGSInsertion implements GSInsertionBlock {
    * Constructs a new default GS insertion block.
    * @param sampleRate The sample rate, in Hertz.
    * @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-   * Attempting to `.process()` more samples than this will result in an error.
+   * Processing more samples than this is not supported and produces undefined output.
    */
   constructor(sampleRate: number, maxBufferSize: number);
   setType(type: number): void;