spessasynth_core 4.4.4 → 4.4.6

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;
@@ -289,6 +290,27 @@ export declare const GeneratorTypes: Readonly<{
   readonly vibLfoToVolume: 65;
   readonly modLfoRate: 66;
   readonly modLfoAmplitudeDepth: 67;
+  readonly ignoreNoteOff: 68;
+  readonly delayVoice: 69;
+  readonly fadeVibLFO: 70;
+  readonly fadeModLFO: 71;
+  readonly vibLfoWaveform: 72;
+  readonly modLfoWaveform: 73;
+  readonly vibLfoStartPhase: 74;
+  readonly modLfoStartPhase: 75;
+  readonly maxFilterFc: 76;
+  readonly decay2VolEnv: 77;
+  readonly sustain2VolEnv: 78;
+  readonly delayModEnv2: 79;
+  readonly attackModEnv2: 80;
+  readonly holdModEnv2: 81;
+  readonly decayModEnv2: 82;
+  readonly sustainModEnv2: 83;
+  readonly releaseModEnv2: 84;
+  readonly keyNumToModEnv2Hold: 85;
+  readonly keyNumToModEnv2Decay: 86;
+  readonly modEnv2ToPitch: 87;
+  readonly modEnv2ToFilterFc: 88;
 }>;
 /**
  * @inheritDoc GeneratorTypes
@@ -331,6 +353,17 @@ export interface GeneratorLimit {
    * SoundFont2 NRPN scale factor for this generator type.
    */
   nrpn: number;
+  /**
+   * Minimum value of this generator in a preset zone.
+   * Preset generators are offsets added to the instrument, so they can go below the instrument range.
+   * If not set, it is the same as `min`.
+   */
+  presetMin?: number;
+  /**
+   * Maximum value of this generator in a preset zone.
+   * If not set, it is the same as `max`.
+   */
+  presetMax?: number;
 }
 /**
  * Limits and defaults for all the {@link BasicSoundBank} generator types.
@@ -393,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;
   /**
@@ -422,7 +455,7 @@ export declare const ModulatorCurveTypes: {
    */
   readonly concave: 1;
   /**
-   * Inverse of concave.
+   * Exponential ramp, the inverse of concave.
    */
   readonly convex: 2;
   /**
@@ -474,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;
   /**
@@ -653,53 +686,27 @@ export declare class BasicZone {
    */
   copyFrom(zone: BasicZone): void;
 }
-/**
- * Represents a single instrument zone with an associated {@link BasicSample}.
- *
- * @group Sound Banks.Zones
- */
-export declare class BasicInstrumentZone extends BasicZone {
-  /**
-   * The instrument this zone belongs to.
-   */
-  readonly parentInstrument: BasicInstrument;
-  /**
-   * Zone's sample.
-   */
-  private _sample;
-  /**
-   * The sample associated with this zone.
-   */
-  get sample(): BasicSample;
-  /**
-   * Sets a sample for this zone, unliking the previous one from it.
-   * @param sample The sample to set.
-   */
-  set sample(sample: BasicSample);
-}
 /**
  * Represents a single preset zone with an associated {@link BasicInstrument}.
  *
  * @group Sound Banks.Zones
  */
-export declare class BasicPresetZone extends BasicZone {
+export declare class BasicPresetZone extends BasicLinkedZone<BasicPreset, BasicInstrument> {
+  protected readonly childGenerator: 41;
   /**
    * The preset this zone belongs to.
    */
-  readonly parentPreset: BasicPreset;
-  /**
-   * The instrument associated with this zone.
-   */
-  private _instrument;
+  get parentPreset(): BasicPreset;
   /**
    * The instrument associated with this zone.
    */
   get instrument(): BasicInstrument;
   /**
-   * Sets an instrument for this zone, unliking the previous one from it.
+   * Sets an instrument for this zone, unlinking the previous one from it.
    * @param instrument The instrument to set.
    */
   set instrument(instrument: BasicInstrument);
+  protected getChildList(bank: BasicSoundBank): BasicInstrument[];
 }
 /**
  * SpessaSynth 4.0 brings the full bank LSB support in the API.
@@ -781,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;
   /**
@@ -794,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;
   /**
@@ -820,18 +836,146 @@ 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;
 }
+/**
+ * Represents a single preset.
+ * This is what is used for MIDI playback.
+ *
+ * @group Sound Banks
+ */
+export declare class BasicPreset implements MIDIPatchFull {
+  /**
+   * The parent soundbank instance
+   * Currently used for determining default modulators and XG status
+   */
+  readonly parentSoundBank: BasicSoundBank;
+  /**
+   * The preset's name.
+   */
+  name: string;
+  program: number;
+  bankMSB: number;
+  bankLSB: number;
+  isGMGSDrum: boolean;
+  /**
+   * The preset's zones.
+   * These are limited to specific key/velocity ranges and contain associated instruments.
+   */
+  zones: BasicPresetZone[];
+  /**
+   * Preset's global zone.
+   * Its parameters are overridden by the local zone parameters.
+   */
+  readonly globalZone: BasicZone;
+  /**
+   * Unused preset metadata, preserved.
+   */
+  library: number;
+  /**
+   * Unused preset metadata, preserved.
+   */
+  genre: number;
+  /**
+   * Unused preset metadata, preserved.
+   */
+  morphology: number;
+  /**
+   * Creates a new preset.
+   * @param parentSoundBank The sound bank this preset belongs to.
+   * @param globalZone The optional global zone to associate within the preset.
+   */
+  constructor(parentSoundBank: BasicSoundBank, globalZone?: BasicZone);
+  /**
+   * A boolean indicating if this preset is a drum preset.
+   */
+  get isDrum(): boolean;
+  private static isInRange;
+  private static addUniqueModulators;
+  private static subtractRanges;
+  /**
+   * Unlinks everything from this preset.
+   * This is what {@link BasicSoundBank.deletePreset} calls, the preset itself stays intact.
+   * Use {@link restore} to undo it.
+   */
+  delete(): void;
+  /**
+   * Links the instruments back to this preset, the inverse of {@link delete}.
+   * Use it to restore a deleted preset, for example when undoing the deletion.
+   * Add the preset back to the sound bank as well.
+   */
+  restore(): void;
+  /**
+   * Deletes a preset zone from this preset.
+   * @param index The zone's index to delete.
+   */
+  deleteZone(index: number): void;
+  /**
+   * Creates a new preset zone and returns it.
+   * @param instrument The instrument to associate with the zone.
+   * @param link If the instrument should be linked to this preset.
+   * Pass false for helper presets that are not part of a sound bank.
+   * Such a zone never changes the instrument's use count or its `linkedTo` list.
+   *
+   * > **Warning**
+   * >
+   * > A preset with unlinked zones must not be added to a sound bank.
+   */
+  createZone(instrument: BasicInstrument, link?: boolean): BasicPresetZone;
+  /**
+   * Preloads (loads and caches synthesis data) for a given key range.
+   * @param keyMin The lowest allowed MIDI note number.
+   * @param keyMax The highest allowed MIDI note number.
+   */
+  preload(keyMin: number, keyMax: number): void;
+  /**
+   * Checks if the bank and program numbers are the same for the given preset as this one.
+   * Shortened version of {@link MIDIPatchTools.matches}
+   * @param preset The preset to check.
+   */
+  matches(preset: MIDIPatch): boolean;
+  /**
+   * Returns the voice synthesis data for this preset.
+   *
+   * > **Note**
+   * >
+   * > The `E-mu` attenuation correction
+   * > (`initialAttenuation` generator value being multiplied by `0.4`) is already performed.
+   *
+   * @param midiNote The MIDI note number.
+   * @param velocity The MIDI velocity.
+   * @returns The returned sound data.
+   */
+  getVoiceParameters(midiNote: number, velocity: number): VoiceParameters[];
+  /**
+   * Alias for {@link MIDIPatchTools.toMIDIString}
+   */
+  toMIDIString(): string;
+  /**
+   * Alias for {@link MIDIPatchTools.toFullMIDIString}
+   */
+  toString(): string;
+  /**
+   * Combines preset into an instrument, flattening the preset zones into instrument zones.
+   * This is a really complex function that attempts to work around the DLS limitations of only having the instrument layer.
+   *
+   * > **Tip**
+   * >
+   * > 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 sound exactly the same as this preset.
+   */
+  toFlattenedInstrument(): BasicInstrument;
+}
 /**
  * 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)
@@ -866,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[];
   /**
@@ -917,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;
@@ -936,16 +1083,18 @@ 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.
+   * @returns The samples whose sample rate or loop points changed.
+   * Compressing resamples samples outside 8000 to 96000 Hz.
    */
-  setSampleFormat(options: SetSampleFormatOptions): Promise<void>;
+  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**
    * >
@@ -995,41 +1144,47 @@ export declare class BasicSoundBank {
    */
   addSamples(...samples: BasicSample[]): void;
   /**
-   * Clones a sample into this bank.
+   * Clones a sample into this bank, together with its stereo partner.
    *
    * > **Important**
    * >
-   * > If a sample with the same name already exists in the sound bank,
+   * > By default, if a sample with the same name already exists in the sound bank,
    * > it is returned instead and the new sample is not copied.
+   * > Use the options or a {@link SoundBankCloner} to change that.
    *
    * @param sample The sample to copy.
+   * @param options Options for cloning.
    * @returns The copied sample.
    */
-  cloneSample(sample: BasicSample): BasicSample;
+  cloneSample(sample: BasicSample, options?: Partial<SoundBankCloneOptions>): BasicSample;
   /**
    * Recursively clones an instrument into this sound bank, as well as its samples.
    *
    * > **Important**
    * >
-   * > If an instrument with the same name already exists in the sound bank,
+   * > By default, if an instrument with the same name already exists in the sound bank,
    * > it is returned instead and the new instrument is not copied.
+   * > Use the options or a {@link SoundBankCloner} to change that.
    *
    * @param instrument The instrument to copy.
+   * @param options Options for cloning.
    * @returns The copied instrument.
    */
-  cloneInstrument(instrument: BasicInstrument): BasicInstrument;
+  cloneInstrument(instrument: BasicInstrument, options?: Partial<SoundBankCloneOptions>): BasicInstrument;
   /**
    * Recursively clones a preset into this sound bank, as well as its instruments and samples.
    *
    * > **Important**
    * >
-   * > If a preset with the same name already exists in the sound bank,
+   * > By default, if a preset with the same name already exists in the sound bank,
    * > it is returned instead and the new preset is not copied.
+   * > Use the options or a {@link SoundBankCloner} to change that.
    *
    * @param preset The preset to copy.
+   * @param options Options for cloning.
    * @returns The copied preset.
    */
-  clonePreset(preset: BasicPreset): BasicPreset;
+  clonePreset(preset: BasicPreset, options?: Partial<SoundBankCloneOptions>): BasicPreset;
   /**
    * Updates internal values. Call after updating the preset list.
    */
@@ -1037,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.
    */
@@ -1091,114 +1245,90 @@ export declare class BasicSoundBank {
   protected printInfo(): void;
 }
 /**
- * Represents a single preset.
- * This is what is used for MIDI playback.
+ * An element that zones can link to, a {@link BasicInstrument} or a {@link BasicSample}.
  *
- * @group Sound Banks
+ * @group Sound Banks.Zones
  */
-export declare class BasicPreset implements MIDIPatchFull {
+interface LinkableZoneChild<P> {
   /**
-   * The parent soundbank instance
-   * Currently used for determining default modulators and XG status
-   */
-  readonly parentSoundBank: BasicSoundBank;
-  /**
-   * The preset's name.
+   * The element's name.
    */
   name: string;
-  program: number;
-  bankMSB: number;
-  bankLSB: number;
-  isGMGSDrum: boolean;
   /**
-   * The preset's zones.
-   * These are limited to specific key/velocity ranges and contain associated instruments.
+   * Links the element to a parent.
+   * @param parent The parent that uses the element.
    */
-  zones: BasicPresetZone[];
+  linkTo(parent: P): void;
   /**
-   * Preset's global zone.
-   * Its parameters are overridden by the local zone parameters.
+   * Unlinks the element from a parent.
+   * @param parent The parent that no longer uses the element.
    */
-  readonly globalZone: BasicZone;
-  /**
-   * Unused preset metadata, preserved.
-   */
-  library: number;
-  /**
-   * Unused preset metadata, preserved.
-   */
-  genre: number;
+  unlinkFrom(parent: P): void;
+}
+/**
+ * A zone that belongs to a parent and uses a child: a preset zone with its instrument,
+ * or an instrument zone with its sample.
+ * It keeps the child linked to the parent while the zone uses it.
+ *
+ * @group Sound Banks.Zones
+ */
+export declare abstract class BasicLinkedZone<P, C extends LinkableZoneChild<P>> extends BasicZone {
   /**
-   * Unused preset metadata, preserved.
+   * The element this zone belongs to.
    */
-  morphology: number;
+  protected readonly parent: P;
   /**
-   * Creates a new preset.
-   * @param parentSoundBank The sound bank this preset belongs to.
-   * @param globalZone The optional global zone to associate within the preset.
+   * The element this zone uses.
    */
-  constructor(parentSoundBank: BasicSoundBank, globalZone?: BasicZone);
+  protected child: C;
   /**
-   * A boolean indicating if this preset is a drum preset.
+   * The generator that stores the child's index when writing.
    */
-  get isDrum(): boolean;
-  private static isInRange;
-  private static addUniqueModulators;
-  private static subtractRanges;
+  protected abstract readonly childGenerator: GeneratorType;
   /**
-   * Deletes a preset zone from this preset.
-   * @param index The zone's index to delete.
+   * If this zone counts as a use of its child.
+   * Zones created without linking never change the child's links.
    */
-  deleteZone(index: number): void;
+  private readonly linked;
   /**
-   * Creates a new preset zone and returns it.
-   * @param instrument The instrument to associate with the zone.
+   * Creates a new zone and links the child to the parent.
+   * @param parent The element this zone belongs to.
+   * @param child The element this zone uses.
+   * @param link If the child should be linked to the parent.
    */
-  createZone(instrument: BasicInstrument): BasicPresetZone;
+  protected constructor(parent: P, child: C, link: boolean);
   /**
-   * Preloads (loads and caches synthesis data) for a given key range.
-   * @param keyMin The lowest allowed MIDI note number.
-   * @param keyMax The highest allowed MIDI note number.
+   * Replaces the child, moving the link from the previous one to the new one.
+   * @param child The new child.
    */
-  preload(keyMin: number, keyMax: number): void;
+  protected setChild(child: C): void;
   /**
-   * Checks if the bank and program numbers are the same for the given preset as this one.
-   * Shortened version of {@link MIDIPatchTools.matches}
-   * @param preset The preset to check.
+   * The bank's list that the child's index is written from.
+   * @param bank The bank being written.
    */
-  matches(preset: MIDIPatch): boolean;
-  /**
-   * Returns the voice synthesis data for this preset.
-   *
-   * > **Note**
-   * >
-   * > The `E-mu` attenuation correction
-   * > (`initialAttenuation` generator value being multiplied by `0.4`) is already performed.
-   *
-   * @param midiNote The MIDI note number.
-   * @param velocity The MIDI velocity.
-   * @returns The returned sound data.
-   */
-  getVoiceParameters(midiNote: number, velocity: number): VoiceParameters[];
+  protected abstract getChildList(bank: BasicSoundBank): C[];
+}
+/**
+ * Represents a single instrument zone with an associated {@link BasicSample}.
+ *
+ * @group Sound Banks.Zones
+ */
+export declare class BasicInstrumentZone extends BasicLinkedZone<BasicInstrument, BasicSample> {
+  protected readonly childGenerator: 53;
   /**
-   * Alias for {@link MIDIPatchTools.toMIDIString}
+   * The instrument this zone belongs to.
    */
-  toMIDIString(): string;
+  get parentInstrument(): BasicInstrument;
   /**
-   * Alias for {@link MIDIPatchTools.toFullMIDIString}
+   * The sample associated with this zone.
    */
-  toString(): string;
+  get sample(): BasicSample;
   /**
-   * Combines preset into an instrument, flattening the preset zones into instrument zones.
-   * This is a really complex function that attempts to work around the DLS limitations of only having the instrument layer.
-   *
-   * > **Tip**
-   * >
-   * > 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.
+   * Sets a sample for this zone, unlinking the previous one from it.
+   * @param sample The sample to set.
    */
-  toFlattenedInstrument(): BasicInstrument;
+  set sample(sample: BasicSample);
+  protected getChildList(bank: BasicSoundBank): BasicSample[];
 }
 /**
  * This class represents a single instrument, a layer below the BasicPreset.
@@ -1239,13 +1369,33 @@ export declare class BasicInstrument {
   /**
    * Creates a new instrument zone, adds it to this instrument and returns it.
    * @param sample The sample to associate with the zone.
+   * @param link If the sample should be linked to this instrument.
+   * Pass false for helper instruments that are not part of a sound bank.
+   * Such a zone never changes the sample's use count or its `linkedTo` list.
+   *
+   * > **Warning**
+   * >
+   * > An instrument with unlinked zones must not be added to a sound bank!
    */
-  createZone(sample: BasicSample): BasicInstrumentZone;
+  createZone(sample: BasicSample, link?: boolean): BasicInstrumentZone;
   /**
    * Unlinks the instrument from a given preset.
    * @param preset The preset to unlink from.
    */
   unlinkFrom(preset: BasicPreset): void;
+  /**
+   * Unlinks everything from this instrument.
+   * This is what {@link BasicSoundBank.deleteInstrument} calls, the instrument itself stays intact.
+   * Use {@link restore} to undo it.
+   * @throws Error if the instrument is still used by a preset.
+   */
+  delete(): void;
+  /**
+   * Links the samples back to this instrument, the inverse of {@link delete}.
+   * Use it to restore a deleted instrument, for example when undoing the deletion.
+   * Add the instrument back to the sound bank as well.
+   */
+  restore(): void;
   /**
    * Deletes a given instrument zone if it has no uses.
    * @param index The index of the zone to delete.
@@ -1299,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;
@@ -1337,6 +1487,19 @@ export declare class BasicSample {
    * The sample's audio data.
    */
   protected audioData?: Float32Array;
+  /**
+   * The signed 16-bit little endian PCM data, as read from the file.
+   */
+  protected s16leData?: Uint8Array;
+  /**
+   * The length in sample points when it is not known from the data,
+   * either a sample without data or a vorbis stream's length that was read once.
+   */
+  protected cachedLength?: number;
+  /**
+   * The form the data had before it was released or when it was loaded without data.
+   */
+  protected releasedForm?: SampleStoredData["form"];
   /**
    * Creates a new `BasicSample`.
    *
@@ -1348,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.
    */
@@ -1357,6 +1520,27 @@ export declare class BasicSample {
    * Indicates if the sample contains compressed audio.
    */
   get isCompressed(): boolean;
+  /**
+   * The form the sample stores its data in, see {@link BasicSample.getStoredData}.
+   * A sample without data reports the form it had, or undefined if it never had data.
+   */
+  get storedForm(): SampleStoredData["form"] | undefined;
+  /**
+   * Indicates if the sample holds any audio data.
+   * A sample loaded with `sampleData: false` or released with {@link BasicSample.releaseData} does not.
+   */
+  get hasData(): boolean;
+  /**
+   * The sample's length in sample points, known without decoding the data.
+   * Samples without data keep the length they had.
+   *
+   * > **Note**
+   * >
+   * > For compressed samples, it is read from the Ogg page headers, which is exact for well-formed streams.
+   * > A stream with gaps in its granule positions decodes shorter. Once it is decoded,
+   * > the length is the decoded one.
+   */
+  get sampleLength(): number;
   /**
    * If the sample is linked to another sample.
    */
@@ -1371,6 +1555,34 @@ export declare class BasicSample {
    * @return either s16le or vorbis data.
    */
   getRawData(allowVorbis: boolean): Uint8Array;
+  /**
+   * Gets the sample's data in the form it is stored, without decoding, encoding or copying it.
+   * Use {@link BasicSample.setStoredData} to give it to another sample, for example in another thread.
+   * @returns The stored form and its data.
+   */
+  getStoredData(): SampleStoredData;
+  /**
+   * Replaces the sample's data with data in a given stored form, without decoding or encoding it.
+   * The sample rate and loop points are not changed.
+   *
+   * > **Note**
+   * >
+   * > s16le and vorbis data is written back unchanged when saving, float32 data is encoded.
+   *
+   * @param stored The stored form and its data, as returned by {@link BasicSample.getStoredData}.
+   */
+  setStoredData(stored: SampleStoredData): void;
+  /**
+   * Drops all the sample's data. The parameters and {@link BasicSample.sampleLength} stay.
+   * Reading the audio data afterward throws an error until {@link BasicSample.setStoredData} gives it new data.
+   */
+  releaseData(): void;
+  /**
+   * Drops the decoded float data if the sample can decode it again from its stored s16le or vorbis data.
+   * Replaced data (set with {@link BasicSample.setAudioData}) is kept.
+   * @returns True if the decoded data was dropped.
+   */
+  releaseDecoded(): boolean;
   /**
    * Resamples the audio data _in-place_ to a given sample rate.
    * @param newSampleRate The new sample rate, in hertz.
@@ -1413,6 +1625,15 @@ export declare class BasicSample {
    * @param data The new compressed data.
    */
   setCompressedData(data: Uint8Array): void;
+  /**
+   * The error for reading the data of a sample that has none.
+   */
+  protected noDataError(): Error;
+  /**
+   * Decodes signed 16-bit little endian PCM into float.
+   * @param data The s16le data. It may be a view at any offset.
+   */
+  protected decodeS16LE(data: Uint8Array): Float32Array<ArrayBuffer>;
   /**
    * Encodes s16le sample
    * @return the encoded data
@@ -1490,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**
  * >
@@ -1547,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;
@@ -1601,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
@@ -1847,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.
@@ -1889,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";
 } | {
@@ -1898,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";
   /**
@@ -1919,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;
 }
@@ -1956,43 +2266,112 @@ export interface SFEWriteOptions extends SoundBankWriteOptions {
    * Increases maximum size from 4GB to effectively infinite.
    * Recommended, since SFE 4 is effectively incompatible with SF2.
    */
-  rf64: boolean;
+  rf64: boolean;
+}
+/**
+ * A simple range interface.
+ *
+ * @group Sound Banks.Zones
+ */
+export interface GenericRange {
+  /**
+   * The minimum value.
+   */
+  min: number;
+  /**
+   * The maximum value.
+   */
+  max: number;
+}
+/**
+ * - Key - the preset.
+ * - Value - A Map:
+ *   - Key: The MIDI note number.
+ *   - Value: A set of all velocities this key was pressed with.
+ *
+ * @group Sound Banks
+ */
+export type PresetsWithKeyCombinations<T extends MIDIPatchFull> = Map<T, Map<number, Set<number>>>;
+/**
+ * One of the General MIDI systems.
+ *
+ * > **Tip**
+ * >
+ * > Consider reading the [MIDI Implementation](../../docs/extra/midi-implementation.md)
+ * to learn more about these systems.
+ *
+ * @group MIDI.Protocol
+ */
+export type MIDISystem = "gm" | "gm2" | "gs" | "xg";
+/**
+ * A sample's data in the form the sample stores it, without decoding or encoding.
+ * - `s16le` - signed 16-bit little endian PCM
+ * - `vorbis` - an Ogg Vorbis stream (SF3)
+ * - `float32` - decoded or replaced float PCM
+ *
+ * @group Sound Banks.Samples
+ */
+export type SampleStoredData = {
+  form: "s16le";
+  data: Uint8Array;
+} | {
+  form: "vorbis";
+  data: Uint8Array;
+} | {
+  form: "float32";
+  data: Float32Array;
+};
+/**
+ * Options for loading a sound bank with {@link SoundBankLoader.fromArrayBuffer}.
+ *
+ * @group Sound Banks
+ */
+export interface SoundBankLoadOptions {
+  /**
+   * If the sample data should be loaded.
+   * When false, the samples keep all their parameters and their length, but hold no data.
+   * Presets, instruments and samples come out in the same order as with a full load.
+   * Use {@link BasicSample.setStoredData} to give a sample its data later.
+   *
+   * > **Note**
+   * >
+   * > DLS files and SF2Pack banks are still decoded fully during loading. The data is dropped afterward.
+   */
+  sampleData: boolean;
+  /**
+   * If the sample data should be copied out of the file buffer.
+   * When false, the samples are views into the given buffer, which saves memory and time during loading,
+   * but keeps the whole buffer alive as long as any of the samples are.
+   *
+   * > **Note**
+   * >
+   * > DLS files always copy their data.
+   */
+  copySampleData: boolean;
 }
 /**
- * A simple range interface.
+ * Options for cloning elements into a sound bank with {@link SoundBankCloner}.
  *
- * @group Sound Banks.Zones
+ * @group Sound Banks
  */
-export interface GenericRange {
+export interface SoundBankCloneOptions {
   /**
-   * The minimum value.
+   * If the cloned element itself is reused when an element with the same name exists in the bank.
+   * When false, it is always copied, under a free name (`Name-1`, `Name-2` and so on).
    */
-  min: number;
+  reuseByName: boolean;
   /**
-   * The maximum value.
+   * If the instruments and samples used by a cloned element are reused when one with the same name exists.
+   * When false, they are copied under a free name as well.
+   * A stereo partner of a copied sample is always copied with it.
    */
-  max: number;
+  reuseChildrenByName: boolean;
+  /**
+   * If the new elements are added to the bank.
+   * When false, they are only listed in {@link SoundBankCloner.created}.
+   */
+  addToBank: boolean;
 }
-/**
- * - Key - the preset.
- * - Value - A Map:
- *   - Key: The MIDI note number.
- *   - Value: A set of all velocities this key was pressed with.
- *
- * @group MIDI.Protocol
- */
-export type PresetsWithKeyCombinations<T extends MIDIPatchFull> = Map<T, Map<number, Set<number>>>;
-/**
- * One of the General MIDI systems.
- *
- * > **Tip**
- * >
- * > Consider reading the [MIDI Implementation](../../docs/extra/midi-implementation.md)
- * to learn more about these systems.
- *
- * @group MIDI.Protocol
- */
-export type MIDISystem = "gm" | "gm2" | "gs" | "xg";
 /**
  * The available interpolation types of the synthesizer.
  * Interpolation defines how sample points between the sample data are calculated.
@@ -2012,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
@@ -2022,6 +2420,32 @@ export declare const InterpolationTypes: {
  * @group Synthesizer.Options
  */
 export type InterpolationType = (typeof InterpolationTypes)[keyof typeof InterpolationTypes];
+/**
+ * The special EFX control sources of a {@link GSInsertionBlock} (EFX CONTROL SOURCE 1/2).
+ * Values `1-95` select the control change with that number, other values are off.
+ *
+ * @group Synthesizer.GS Effects
+ */
+export declare const GSInsertionControlSources: {
+  /**
+   * No control.
+   */
+  readonly off: 0;
+  /**
+   * Channel aftertouch (channel pressure).
+   */
+  readonly channelPressure: 112;
+  /**
+   * Pitch bend.
+   */
+  readonly pitchBend: 113;
+};
+/**
+ * @inheritDoc GSInsertionControlSources
+ *
+ * @group Synthesizer.GS Effects
+ */
+export type GSInsertionControlSource = (typeof GSInsertionControlSources)[keyof typeof GSInsertionControlSources];
 /**
  * Channel System Parameters are API-only parameters
  * that affect a single MIDI channel.
@@ -2096,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.
    */
@@ -2104,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.
    */
@@ -2320,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
@@ -2329,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).
@@ -2451,6 +2877,35 @@ export interface GSInsertionParameter {
    * Higher values result in more sound being sent.
    */
   sendLevelToDelay: number;
+  /**
+   * `0-127`
+   *
+   * EFX control source 1: the controller that modulates the first controlled parameter of the type
+   * (marked with `+` in the SC-8850 manual).
+   * `1-95` selects a control change number, see {@link GSInsertionControlSources} for the others.
+   * Only the parts with EFX assigned (see {@link ChannelMIDIParameter.efxAssign}) control it.
+   */
+  controlSource1: number;
+  /**
+   * `0-127`
+   *
+   * EFX control depth 1: how far control source 1 moves its parameter,
+   * from `0` (-100%) through `64` (0%) to `127` (+100%) of the full parameter range.
+   */
+  controlDepth1: number;
+  /**
+   * `0-127`
+   *
+   * EFX control source 2: the controller that modulates the second controlled parameter of the type
+   * (marked with `#` in the SC-8850 manual). See {@link controlSource1}.
+   */
+  controlSource2: number;
+  /**
+   * `0-127`
+   *
+   * EFX control depth 2, see {@link controlDepth1}.
+   */
+  controlDepth2: number;
 }
 /**
  * A snapshot of a {@link GSInsertionBlock}.
@@ -2475,6 +2930,10 @@ export interface GSInsertionBlockSnapshot extends GSInsertionParameter {
    * Value `255` means the parameter has not been changed since the type was set, so it uses the type default.
    */
   params: Uint8Array;
+  /**
+   * The last controller values of the two EFX control sources (signed, pitch bend is centered at 0).
+   */
+  controlValues: number[];
 }
 /**
  * The Insertion effect (EFX) processes the parts (channels) that have EFX assigned
@@ -2504,6 +2963,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.
+   * The EFX control sources and depths are kept.
    * Behavior for unsupported types is up to the implementation.
    *
    * @param type The 16-bit type value to use, `MSB << 8 | LSB`.
@@ -2515,7 +2975,7 @@ export interface GSInsertionBlock extends GSInsertionParameter {
    */
   getType(): number;
   /**
-   * Resets this block to default values, including the EFX type and the send levels.
+   * Resets this block to default values, including the EFX type, the send levels and the EFX control.
    */
   reset(): void;
   /**
@@ -2524,6 +2984,14 @@ export interface GSInsertionBlock extends GSInsertionParameter {
    * @param value The 7-bit value.
    */
   setParameter(param: number, value: number): void;
+  /**
+   * Passes a controller value of a part with EFX assigned (see {@link ChannelMIDIParameter.efxAssign})
+   * for the EFX control sources ({@link controlSource1}, {@link controlSource2}).
+   * @param source The controller, encoded like the control sources:
+   * `1-95` a control change number, or a value of {@link GSInsertionControlSources}.
+   * @param value The controller value: 7-bit, or 14-bit for {@link GSInsertionControlSources.pitchBend}.
+   */
+  setControllerValue(source: number, value: number): void;
   /**
    * Process the effect and **adds** it to the output.
    * @param inputLeft The left input buffer to process. It always starts at index 0.
@@ -2571,7 +3039,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
@@ -2651,7 +3119,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;
 }
 /**
@@ -2733,13 +3208,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;
 }
 /**
@@ -2751,7 +3233,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;
 }
@@ -2796,7 +3278,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;
 }
 /**
@@ -2809,7 +3298,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.
    */
@@ -2885,7 +3374,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;
 }
 /**
@@ -2936,7 +3432,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;
   /**
@@ -2957,7 +3453,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;
   /**
@@ -3085,7 +3581,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;
   /**
@@ -3164,6 +3664,15 @@ export declare class SoundBankManager {
    * @param bankOffset The bank offset of the sound bank. Offsets the bank MSB value of all presets in this sound bank.
    */
   addSoundBank(bank: BasicSoundBank, id: string, bankOffset?: number): void;
+  /**
+   * Rebuilds the preset list from the current sound banks.
+   * Call it after editing a sound bank that is already added,
+   * for example after adding, removing or renumbering presets.
+   *
+   * The synthesizer then updates its channels to the new presets without resetting,
+   * see {@link SpessaSynthProcessor.refreshPresets}.
+   */
+  refresh(): void;
   private generatePresetList;
 }
 /**
@@ -3562,6 +4071,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.
@@ -3577,7 +4091,7 @@ export declare class SpessaSynthProcessor {
   setSystemParameter<P extends keyof GlobalSystemParameter>(parameter: P, value: GlobalSystemParameter[P]): void;
   /**
    * A handler for missing presets during program change.
-   * By default, it warns to console.
+   * By default, it warns to console, unless no sound bank has been added yet.
    * It may be useful for allowing the synthesizer to work without any sound banks.
    * @param patch The MIDI patch that was requested.
    * @param system The MIDI System for the request.
@@ -3592,7 +4106,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.
@@ -3683,11 +4197,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;
   /**
@@ -3697,6 +4211,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;
@@ -3743,6 +4260,20 @@ export declare class SpessaSynthProcessor {
    * These shouldn't be added to the `left` and `right` outputs. Recommended use-case is visualization.
    */
   process(left: Float32Array, right: Float32Array, startIndex?: number, sampleCount?: number, channelOutputs?: Float32Array[][]): void;
+  /**
+   * Updates the synthesizer after the added sound banks were edited.
+   * It rebuilds the preset list, clears the voice cache,
+   * and points every channel at the current preset for its patch.
+   *
+   * Unlike adding a sound bank, this does not reset the synthesizer or send program changes,
+   * so playback continues. Voices that are already playing keep the old data until they end.
+   *
+   * > **Tip**
+   * >
+   * > Call it after adding, removing or renumbering presets in a sound bank that is already added.
+   * > For edits inside existing presets, {@link clearCache} is enough.
+   */
+  refreshPresets(): void;
   /**
    * Clears the synthesizer's voice cache.
    * This can be used to hear the changes after editing a {@link BasicSoundBank}
@@ -3883,7 +4414,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
  */
@@ -3915,7 +4446,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
  */
@@ -3947,7 +4478,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
  */
@@ -3979,7 +4510,7 @@ export type GSDelayParameterMessage = { [P in keyof GSDelayParameter]: {
   value: number;
 };
 /**
- * Represents an analyzed channel GS Insertion Processor change.
+ * Represents an analyzed GS Insertion Processor change.
  *
  * @group MIDI.Protocol
  */
@@ -4002,9 +4533,9 @@ export type GSInsertionParameterMessage = {
    */
   type: "GS Insertion Param";
   /**
-   * The parameter name that was modified in the processor.
+   * The parameter name that was modified in the processor: a send level or an EFX control setting.
    */
-  parameter: "sendLevelToReverb" | "sendLevelToChorus" | "sendLevelToDelay";
+  parameter: keyof GSInsertionParameter;
   /**
    * The new value of the parameter.
    */
@@ -4494,7 +5025,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
  */
@@ -4637,6 +5168,7 @@ export type EffectChangeEvent = {
    * The parameter that was changed:
    * - `"type"` - 16-bit effect type (`MSB << 8 | LSB`). Note that this resets the parameters and the send levels!
    * - `"sendLevelToReverb" | "sendLevelToChorus" | "sendLevelToDelay"` - send levels (7-bit), see {@link GSInsertionParameter}.
+   * - `"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;
@@ -4769,12 +5301,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.      |
@@ -4787,6 +5318,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 {
@@ -4800,7 +5336,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**
    * >
@@ -4819,7 +5355,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;
   /**
@@ -4852,9 +5388,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**
    * >
@@ -4868,9 +5405,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
    *
@@ -4985,6 +5523,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>;
@@ -5004,8 +5544,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;
@@ -5028,8 +5569,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.
@@ -5043,6 +5594,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
  */
@@ -5051,7 +5604,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;
@@ -5059,6 +5612,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
  */
@@ -5068,11 +5623,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;
@@ -5080,11 +5641,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
  */
@@ -5097,12 +5665,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;
@@ -5113,11 +5687,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
  */
@@ -5127,16 +5709,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;
 }
 /**
@@ -5156,7 +5748,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;
 }
@@ -5177,6 +5770,18 @@ export interface SynthMethodOptions {
  * @group Synthesizer.Options
  */
 export interface SynthProcessorOptions {
+  /**
+   * The most decoded sample data the synthesizer keeps, in bytes.
+   * When over it, the least recently played samples drop their decoded data and decode again when played.
+   * Only samples that can decode again (loaded s16le or vorbis data) are dropped.
+   * Defaults to Infinity, which keeps everything.
+   *
+   * > **Tip**
+   * >
+   * > Decoded data is 4 bytes per sample point, twice the size of 16-bit data.
+   * > This helps with very large sound banks.
+   */
+  decodedSampleBudget: number;
   /**
    * The maximum buffer size the synthesizer can render at once.
    * Attempting to `.process()` more samples than this will result in an error.
@@ -5298,11 +5903,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.
    */
@@ -5464,7 +6064,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)),
@@ -5727,7 +6327,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.
    */
@@ -5754,8 +6354,9 @@ interface ModifyMIDIOptions {
    * The GS Insertion Effect parameters.
    * - `"clear"` - all existing parameter change MIDI messages are cleared.
    * - {@link GSInsertionBlockSnapshot} - clear + the new parameters are set via System Exclusive messages.
+   * The controller values of the EFX control sources are not part of it, they come from the controllers.
    */
-  gsInsertionParams?: ClearableParameter<GSInsertionBlockSnapshot>;
+  gsInsertionParams?: ClearableParameter<Omit<GSInsertionBlockSnapshot, "controlValues">>;
   /**
    * The desired XG reverb parameters.
    * - `"clear"` - all existing parameter change MIDI messages are removed.
@@ -5786,8 +6387,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"`.
    *
@@ -5835,7 +6437,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;
   /**
@@ -5849,6 +6451,7 @@ export interface RMIDInfoData {
   midiEncoding: string;
   /**
    * The software used to write the file.
+   * If not provided, `SpessaSynth` is used.
    */
   software: string;
   /**
@@ -5857,6 +6460,8 @@ export interface RMIDInfoData {
   subject: string;
 }
 /**
+ * A single tempo change in a MIDI sequence.
+ *
  * @group MIDI.Sequence
  */
 export interface TempoChange {
@@ -5890,7 +6495,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";
 }
@@ -5904,7 +6509,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 {
   /**
@@ -5941,8 +6548,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">>;
@@ -5954,7 +6563,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;
 }
@@ -5965,6 +6574,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 {
@@ -6128,7 +6739,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>;
   /**
@@ -6148,7 +6759,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;
@@ -6277,7 +6888,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;
   /**
@@ -6291,6 +6903,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.
    *
@@ -6356,7 +6969,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.
    */
@@ -6373,7 +6986,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;
@@ -6405,7 +7018,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.
    */
@@ -6424,6 +7037,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,
@@ -6472,7 +7091,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.
@@ -6481,11 +7100,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.
@@ -6523,7 +7147,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
@@ -6559,6 +7183,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;
   /**
@@ -6566,8 +7192,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**
    * >
@@ -6613,6 +7241,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.
@@ -6620,6 +7254,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.
    */
@@ -6633,7 +7272,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.
    */
@@ -6667,11 +7306,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;
 }
@@ -6686,6 +7327,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
  */
@@ -6829,7 +7471,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;
   /**
@@ -6840,7 +7482,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;
   /**
@@ -6876,7 +7518,7 @@ export declare class MIDIUtils {
   /**
    * 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 name,
+   * @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.
    * @returns The {@link MIDIMessage} needed to set this GS Insertion Parameter.
@@ -7104,7 +7746,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.
    */
@@ -7162,7 +7804,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;
   /**
@@ -7170,7 +7816,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;
   };
@@ -7476,7 +8123,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;
@@ -7498,12 +8145,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;
@@ -7550,7 +8197,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;
@@ -7630,7 +8277,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;
@@ -7688,6 +8335,14 @@ export declare class DefaultGSInsertion implements GSInsertionBlock {
   sendLevelToReverb: number;
   sendLevelToChorus: number;
   sendLevelToDelay: number;
+  controlSource1: number;
+  controlDepth1: number;
+  controlSource2: number;
+  controlDepth2: number;
+  /**
+   * The last controller values of both control sources (signed, pitch bend is centered).
+   */
+  private readonly controlValues;
   /**
    * The list of effects available in this block.
    * Effect type: processor.
@@ -7722,16 +8377,21 @@ 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;
   getType(): number;
   reset(): void;
+  setControllerValue(source: number, value: number): void;
   setParameter(param: number, value: number): void;
   process(inputLeft: Float32Array, inputRight: Float32Array, outputLeft: Float32Array, outputRight: Float32Array, outputReverb: Float32Array, outputChorus: Float32Array, outputDelay: Float32Array, startIndex: number, sampleCount: number): void;
   getSnapshot(): GSInsertionBlockSnapshot;
   applySnapshot(snapshot: GSInsertionBlockSnapshot): void;
+  /**
+   * Sends the offsets of both control sources to the processor.
+   */
+  private updateControl;
 }
 /**
  * Synthesizer's default voice cap.
@@ -7777,6 +8437,82 @@ export declare const DEFAULT_MIDI_CONTROLLERS: Readonly<Int16Array>;
  * @group Synthesizer.Drum Sets
  */
 export declare const DEFAULT_DRUM_REVERB: Int8Array<ArrayBuffer>;
+/**
+ * The default clone options, matching {@link BasicSoundBank.clonePreset} and the other clone methods:
+ * every element with a name already in the bank is reused, and the copies are added to the bank.
+ *
+ * @group Sound Banks
+ */
+export declare const DEFAULT_SOUND_BANK_CLONE_OPTIONS: SoundBankCloneOptions;
+/**
+ * Clones presets, instruments and samples into a sound bank, as one session.
+ * Elements copied once in a session are reused when something else in the session uses them again,
+ * so an instrument used by two cloned presets is only copied once.
+ * Stereo pairs are always cloned together.
+ *
+ * > **Tip**
+ * >
+ * > With `addToBank: false`, nothing is added to the bank. The new elements are listed in {@link created},
+ * > in an order they can be added in (samples first, then instruments, then presets).
+ * > Their zones still link to the children they use, like {@link BasicInstrument.createZone} does,
+ * > so a reused child in the bank counts them as users.
+ *
+ * @group Sound Banks
+ */
+export declare class SoundBankCloner {
+  /**
+   * The new elements this session made, in the order they were made. Reused elements are not listed.
+   */
+  readonly created: {
+    samples: BasicSample[];
+    instruments: BasicInstrument[];
+    presets: BasicPreset[];
+  };
+  /**
+   * The bank the elements are cloned into.
+   */
+  readonly bank: BasicSoundBank;
+  /**
+   * The options of this session.
+   */
+  readonly options: SoundBankCloneOptions;
+  private readonly sampleClones;
+  private readonly instrumentClones;
+  /**
+   * Creates a new clone session.
+   * @param bank The bank to clone elements into.
+   * @param options The options for this session.
+   */
+  constructor(bank: BasicSoundBank, options?: Partial<SoundBankCloneOptions>);
+  /**
+   * Clones a sample and its stereo partner.
+   * The data is shared with the original, not copied.
+   * @param sample The sample to clone.
+   * @returns The clone, or the existing sample with the same name if it is reused.
+   */
+  cloneSample(sample: BasicSample): BasicSample;
+  /**
+   * Clones an instrument and the samples it uses.
+   * @param instrument The instrument to clone.
+   * @returns The clone, or the existing instrument with the same name if it is reused.
+   */
+  cloneInstrument(instrument: BasicInstrument): BasicInstrument;
+  /**
+   * Clones a preset and the instruments and samples it uses.
+   * @param preset The preset to clone.
+   * @returns The clone, or the existing preset with the same name if it is reused.
+   */
+  clonePreset(preset: BasicPreset): BasicPreset;
+  private copyInstrument;
+  private copySample;
+  private getFreeName;
+}
+/**
+ * The default options for loading a sound bank: full loading with copied sample data.
+ *
+ * @group Sound Banks
+ */
+export declare const DEFAULT_SOUND_BANK_LOAD_OPTIONS: SoundBankLoadOptions;
 /**
  * A helper class for loading sound bank files as {@link BasicSoundBank} instances.
  *
@@ -7786,9 +8522,10 @@ export declare class SoundBankLoader {
   /**
    * Loads a sound bank from a file buffer.
    * @param buffer The binary file buffer to load.
+   * @param options Options for loading the sample data.
    * @returns The loaded sound bank.
    */
-  static fromArrayBuffer(buffer: ArrayBuffer): BasicSoundBank;
+  static fromArrayBuffer(buffer: ArrayBuffer, options?: Partial<SoundBankLoadOptions>): BasicSoundBank;
 }
-export type { ChannelDrumModification, ChannelGenerators, ChannelMIDIParameter, ChannelModification, ChannelSnapshot, ChannelSystemParameter, ClearableParameter, FourCC, GenericRIFFFourCC, GlobalMIDIParameter, GlobalSystemParameter, MIDIController, MIDIMessageType, ModifyMIDIOptions, SynthesizerSnapshot, UserDrumModification, WAVFourCC };
+export type { ChannelDrumModification, ChannelGenerators, ChannelMIDIParameter, ChannelModification, ChannelSnapshot, ChannelSystemParameter, ClearableParameter, FourCC, GenericRIFFFourCC, GlobalMIDIParameter, GlobalSystemParameter, LinkableZoneChild, MIDIController, MIDIMessageType, ModifyMIDIOptions, SynthesizerSnapshot, UserDrumModification, WAVFourCC };
 //# sourceMappingURL=index.d.ts.map