@coderline/alphatab 1.3.0-alpha.712 → 1.3.0-alpha.724

package/dist/alphaTab.d.ts

@@ -392,6 +392,11 @@ declare class DisplaySettings {
      * The number of bars that should be rendered per partial. This setting is not used by all layouts.
      */
     barCountPerPartial: number;
+    /**
+     * Whether the last system (row) should be also justified to the whole width of the music sheet.
+     * (applies only for page layout).
+     */
+    justifyLastSystem: boolean;
     /**
      * Gets or sets the resources used during rendering. This defines all fonts and colors used.
      * @json_partial_names
@@ -1058,96 +1063,391 @@ interface IWriteable {
 }
 
 /**
- * Lists all midi events.
+ * Lists all midi controllers.
  */
-declare enum MidiEventType {
+declare enum ControllerType {
     /**
-     * A per note pitch bend. (Midi 2.0)
+     * Bank Select. MSB
      */
-    PerNotePitchBend = 96,
+    BankSelectCoarse = 0,
+    /**
+     * Modulation wheel or lever MSB
+     */
+    ModulationCoarse = 1,
     /**
-     * A note is released.
+     * Data entry MSB
      */
-    NoteOff = 128,
+    DataEntryCoarse = 6,
     /**
-     * A note is started.
+     * Channel Volume MSB
      */
-    NoteOn = 144,
+    VolumeCoarse = 7,
     /**
-     * The pressure that was used to play the note.
+     * Pan MSB
      */
-    NoteAftertouch = 160,
+    PanCoarse = 10,
     /**
-     * Change of a midi controller
+     * Expression Controller MSB
      */
-    Controller = 176,
+    ExpressionControllerCoarse = 11,
+    BankSelectFine = 32,
     /**
-     * Change of a midi program
+     * Modulation wheel or level LSB
      */
-    ProgramChange = 192,
+    ModulationFine = 33,
+    /**
+     * Data Entry LSB
+     */
+    DataEntryFine = 38,
+    /**
+     * Channel Volume LSB
+     */
+    VolumeFine = 39,
+    /**
+     * Pan LSB
+     */
+    PanFine = 42,
+    /**
+     * Expression controller LSB
+     */
+    ExpressionControllerFine = 43,
+    /**
+     * Damper pedal (sustain)
+     */
+    HoldPedal = 64,
     /**
-     * The pressure that should be applied to the whole channel.
+     * Legato Footswitch
+     */
+    LegatoPedal = 68,
+    /**
+     * Non-Registered Parameter Number LSB
+     */
+    NonRegisteredParameterFine = 98,
+    /**
+     * Non-Registered Parameter Number MSB
+     */
+    NonRegisteredParameterCourse = 99,
+    /**
+     * Registered Parameter Number LSB
      */
-    ChannelAftertouch = 208,
+    RegisteredParameterFine = 100,
     /**
-     * A change of the audio pitch.
+     * Registered Parameter Number MSB
      */
+    RegisteredParameterCourse = 101,
+    AllSoundOff = 120,
+    /**
+     * Reset all controllers
+     */
+    ResetControllers = 121,
+    /**
+     * All notes of.
+     */
+    AllNotesOff = 123
+}
+
+/**
+ * Lists all midi event types. Based on the type the instance is a specific subclass.
+ */
+declare enum MidiEventType {
+    TimeSignature = 88,
+    NoteOn = 128,
+    NoteOff = 144,
+    ControlChange = 176,
+    ProgramChange = 192,
+    TempoChange = 81,
     PitchBend = 224,
+    PerNotePitchBend = 96,
+    EndOfTrack = 47,
+    AlphaTabRest = 241,
+    AlphaTabMetronome = 242,
     /**
-     * A System Exclusive event.
+     * @deprecated Not used anymore internally. move to the other concrete types.
      */
     SystemExclusive = 240,
     /**
-     * A System Exclusive event.
+     * @deprecated Not used anymore internally. move to the other concrete types.
      */
     SystemExclusive2 = 247,
     /**
-     * A meta event. See `MetaEventType` for details.
+     * @deprecated Not used anymore internally. move to the other concrete types.
      */
     Meta = 255
 }
 /**
  * Represents a midi event.
  */
-declare class MidiEvent {
+declare abstract class MidiEvent {
     /**
      * Gets or sets the track to which the midi event belongs.
      */
     track: number;
-    /**
-     * Gets or sets the raw midi message.
-     */
-    message: number;
     /**
      * Gets or sets the absolute tick of this midi event.
      */
     tick: number;
-    get channel(): number;
-    get command(): MidiEventType;
-    get data1(): number;
-    set data1(value: number);
-    get data2(): number;
-    set data2(value: number);
+    /**
+     * Gets or sets the midi command (type) of this event.
+     */
+    type: MidiEventType;
     /**
      * Initializes a new instance of the {@link MidiEvent} class.
      * @param track The track this event belongs to.
      * @param tick The absolute midi ticks of this event.
-     * @param status The status information of this event.
-     * @param data1 The first data component of this midi event.
-     * @param data2 The second data component of this midi event.
+     * @param command The type of this event.
+     */
+    constructor(track: number, tick: number, command: MidiEventType);
+    /**
+     * @deprecated Change to `type`
+     */
+    get command(): MidiEventType;
+    /**
+     * @deprecated Use individual properties to access data.
+     */
+    get message(): number;
+    /**
+     * @deprecated Use individual properties to access data.
      */
-    constructor(track: number, tick: number, status: number, data1: number, data2: number);
+    get data1(): number;
+    /**
+     * @deprecated Use individual properties to access data.
+     */
+    get data2(): number;
     /**
      * Writes the midi event as binary into the given stream.
      * @param s The stream to write to.
      */
+    abstract writeTo(s: IWriteable): void;
+}
+/**
+ * Represents a time signature change event.
+ */
+declare class TimeSignatureEvent extends MidiEvent {
+    /**
+     * The time signature numerator.
+     */
+    numerator: number;
+    /**
+     * The denominator index is a negative power of two: 2 represents a quarter-note, 3 represents an eighth-note, etc.
+     * Denominator = 2^(index)
+     */
+    denominatorIndex: number;
+    /**
+     * The number of MIDI clocks in a metronome click
+     */
+    midiClocksPerMetronomeClick: number;
+    /**
+     * The number of notated 32nd-notes in what MIDI thinks of as a quarter-note (24 MIDI Clocks).
+     */
+    thirtySecondNodesInQuarter: number;
+    constructor(track: number, tick: number, numerator: number, denominatorIndex: number, midiClocksPerMetronomeClick: number, thirtySecondNodesInQuarter: number);
+    writeTo(s: IWriteable): void;
+}
+/**
+ * The base class for alphaTab specific midi events (like metronomes and rests).
+ */
+declare abstract class AlphaTabSysExEvent extends MidiEvent {
+    static readonly AlphaTabManufacturerId = 125;
+    static readonly MetronomeEventId = 0;
+    static readonly RestEventId = 1;
+    constructor(track: number, tick: number, type: MidiEventType);
+    writeTo(s: IWriteable): void;
+    protected abstract writeEventData(s: IWriteable): void;
+}
+/**
+ * Represents a metronome event. This event is emitted by the synthesizer only during playback and
+ * is typically not part of the midi file itself.
+ */
+declare class AlphaTabMetronomeEvent extends AlphaTabSysExEvent {
+    /**
+     * The metronome counter as per current time signature.
+     */
+    metronomeNumerator: number;
+    /**
+     * The duration of the metronome tick in MIDI ticks.
+     */
+    metronomeDurationInTicks: number;
+    /**
+     * The duration of the metronome tick in milliseconds.
+     */
+    metronomeDurationInMilliseconds: number;
+    /**
+     * Gets a value indicating whether the current event is a metronome event.
+     */
+    readonly isMetronome: boolean;
+    constructor(track: number, tick: number, counter: number, durationInTicks: number, durationInMillis: number);
+    protected writeEventData(s: IWriteable): void;
+}
+/**
+ * Represents a REST beat being 'played'. This event supports alphaTab in placing the cursor.
+ */
+declare class AlphaTabRestEvent extends AlphaTabSysExEvent {
+    channel: number;
+    constructor(track: number, tick: number, channel: number);
+    protected writeEventData(s: IWriteable): void;
+}
+/**
+ * The base class for note related events.
+ */
+declare abstract class NoteEvent extends MidiEvent {
+    /**
+     * The channel on which the note is played.
+     */
+    channel: number;
+    /**
+     * The key of the note being played (aka. the note height).
+     */
+    noteKey: number;
+    /**
+     * The velocity in which the 'key' of the note is pressed (aka. the loudness/intensity of the note).
+     */
+    noteVelocity: number;
+    constructor(track: number, tick: number, type: MidiEventType, channel: number, noteKey: number, noteVelocity: number);
+    get data1(): number;
+    get data2(): number;
+}
+/**
+ * Represents a note being played
+ */
+declare class NoteOnEvent extends NoteEvent {
+    constructor(track: number, tick: number, channel: number, noteKey: number, noteVelocity: number);
+    writeTo(s: IWriteable): void;
+}
+/**
+ * Represents a note stop being played.
+ */
+declare class NoteOffEvent extends NoteEvent {
+    constructor(track: number, tick: number, channel: number, noteKey: number, noteVelocity: number);
+    writeTo(s: IWriteable): void;
+}
+/**
+ * Represents the change of a value on a midi controller.
+ */
+declare class ControlChangeEvent extends MidiEvent {
+    /**
+     * The channel for which the controller is changing.
+     */
+    channel: number;
+    /**
+     * The type of the controller which is changing.
+     */
+    controller: ControllerType;
+    /**
+     * The new value of the controller. The meaning is depending on the controller type.
+     */
+    value: number;
+    constructor(track: number, tick: number, channel: number, controller: ControllerType, value: number);
+    writeTo(s: IWriteable): void;
+    get data1(): number;
+    get data2(): number;
+}
+/**
+ * Represents the change of the midi program on a channel.
+ */
+declare class ProgramChangeEvent extends MidiEvent {
+    /**
+     * The midi channel for which the program changes.
+     */
+    channel: number;
+    /**
+     * The numeric value of the program indicating the instrument bank to choose.
+     */
+    program: number;
+    constructor(track: number, tick: number, channel: number, program: number);
+    writeTo(s: IWriteable): void;
+    get data1(): number;
+}
+/**
+ * Represents a change of the tempo in the song.
+ */
+declare class TempoChangeEvent extends MidiEvent {
+    /**
+     * The tempo in microseconds per quarter note (aka USQ). A time format typically for midi.
+     */
+    microSecondsPerQuarterNote: number;
+    constructor(tick: number, microSecondsPerQuarterNote: number);
+    writeTo(s: IWriteable): void;
+}
+/**
+ * Represents a change of the pitch bend (aka. pitch wheel) on a specific channel.
+ */
+declare class PitchBendEvent extends MidiEvent {
+    /**
+     * The channel for which the pitch bend changes.
+     */
+    channel: number;
+    /**
+     * The value to which the pitch changes. This value is according to the MIDI specification.
+     */
+    value: number;
+    constructor(track: number, tick: number, channel: number, value: number);
+    writeTo(s: IWriteable): void;
+    get data1(): number;
+    get data2(): number;
+}
+/**
+ * Represents a single note pitch bend change.
+ */
+declare class NoteBendEvent extends MidiEvent {
+    /**
+     * The channel on which the note is played for which the pitch changes.
+     */
+    channel: number;
+    /**
+     * The key of the note for which the pitch changes.
+     */
+    noteKey: number;
+    /**
+     * The value to which the pitch changes. This value is according to the MIDI specification.
+     */
+    value: number;
+    constructor(track: number, tick: number, channel: number, noteKey: number, value: number);
+    writeTo(s: IWriteable): void;
+}
+/**
+ * Represents the end of the track indicating that no more events for this track follow.
+ */
+declare class EndOfTrackEvent extends MidiEvent {
+    constructor(track: number, tick: number);
     writeTo(s: IWriteable): void;
 }
 
+/**
+ * Lists the different midi file formats which are supported for export.
+ */
+declare enum MidiFileFormat {
+    /**
+     * A single track multi channel file (SMF Type 0)
+     */
+    SingleTrackMultiChannel = 0,
+    /**
+     * A multi track file (SMF Type 1)
+     */
+    MultiTrack = 1
+}
+declare class MidiTrack {
+    /**
+     * Gets a list of midi events sorted by time.
+     */
+    readonly events: MidiEvent[];
+    /**
+     * Adds the given midi event a the correct time position into the file.
+     */
+    addEvent(e: MidiEvent): void;
+    /**
+     * Writes the midi track as binary into the given stream.
+     * @returns The stream to write to.
+     */
+    writeTo(s: IWriteable): void;
+}
 /**
  * Represents a midi file with a single track that can be played via {@link AlphaSynth}
  */
 declare class MidiFile {
+    /**
+     * Gets or sets the midi file format to use.
+     */
+    format: MidiFileFormat;
     /**
      * Gets or sets the division per quarter notes.
      */
@@ -1155,7 +1455,12 @@ declare class MidiFile {
     /**
      * Gets a list of midi events sorted by time.
      */
-    readonly events: MidiEvent[];
+    get events(): MidiEvent[];
+    /**
+     * Gets a list of midi tracks.
+     */
+    readonly tracks: MidiTrack[];
+    private ensureTracks;
     /**
      * Adds the given midi event a the correct time position into the file.
      */
@@ -2505,6 +2810,10 @@ declare class Chord {
      * Gets or sets whether the fingering is shown below the chord diagram.
      */
     showFingering: boolean;
+    /**
+     * Gets a unique id for this chord based on its properties.
+     */
+    get uniqueId(): string;
 }
 
 /**
@@ -4039,7 +4348,6 @@ interface IAlphaSynth {
     countInVolume: number;
     /**
      * Gets or sets the midi events which will trigger the `midiEventsPlayed` event.
-     * To subscribe to Metronome events use the `SystemExclusiveEvent2` event type and check against `event.isMetronome`
      */
     midiEventsPlayedFilter: MidiEventType[];
     /**
@@ -4744,7 +5052,7 @@ interface IUiFacade<TSettings> {
      * Tells the UI layer to append the given render results to the UI. At this point
      * the partial result is not actually rendered yet, only the layouting process
      * completed.
-     * @param renderResults The rendered partial that should be added to the UI.
+     * @param renderResults The rendered partial that should be added to the UI. null indicates the rendering finished.
      */
     beginAppendRenderResults(renderResults: RenderFinishedEventArgs | null): void;
     /**
@@ -5129,7 +5437,7 @@ declare class AlphaTabApi extends AlphaTabApiBase<any | Settings> {
     constructor(element: HTMLElement, options: any | Settings);
     tex(tex: string, tracks?: number[]): void;
     print(width?: string, additionalSettings?: unknown): void;
-    downloadMidi(): void;
+    downloadMidi(format?: MidiFileFormat): void;
     changeTrackMute(tracks: Track[], mute: boolean): void;
     changeTrackSolo(tracks: Track[], solo: boolean): void;
     changeTrackVolume(tracks: Track[], volume: number): void;
@@ -5295,166 +5603,6 @@ declare namespace index_d$4 {
   };
 }
 
-/**
- * Lists all midi controllers.
- */
-declare enum ControllerType {
-    /**
-     * Bank Select. MSB
-     */
-    BankSelectCoarse = 0,
-    /**
-     * Modulation wheel or lever MSB
-     */
-    ModulationCoarse = 1,
-    /**
-     * Data entry MSB
-     */
-    DataEntryCoarse = 6,
-    /**
-     * Channel Volume MSB
-     */
-    VolumeCoarse = 7,
-    /**
-     * Pan MSB
-     */
-    PanCoarse = 10,
-    /**
-     * Expression Controller MSB
-     */
-    ExpressionControllerCoarse = 11,
-    /**
-     * Modulation wheel or level LSB
-     */
-    ModulationFine = 33,
-    /**
-     * Data Entry LSB
-     */
-    DataEntryFine = 38,
-    /**
-     * Channel Volume LSB
-     */
-    VolumeFine = 39,
-    /**
-     * Pan LSB
-     */
-    PanFine = 42,
-    /**
-     * Expression controller LSB
-     */
-    ExpressionControllerFine = 43,
-    /**
-     * Damper pedal (sustain)
-     */
-    HoldPedal = 64,
-    /**
-     * Legato Footswitch
-     */
-    LegatoPedal = 68,
-    /**
-     * Non-Registered Parameter Number LSB
-     */
-    NonRegisteredParameterFine = 98,
-    /**
-     * Non-Registered Parameter Number MSB
-     */
-    NonRegisteredParameterCourse = 99,
-    /**
-     * Registered Parameter Number LSB
-     */
-    RegisteredParameterFine = 100,
-    /**
-     * Registered Parameter Number MSB
-     */
-    RegisteredParameterCourse = 101,
-    /**
-     * Reset all controllers
-     */
-    ResetControllers = 121,
-    /**
-     * All notes of.
-     */
-    AllNotesOff = 123
-}
-
-declare enum MetaEventType {
-    SequenceNumber = 0,
-    TextEvent = 1,
-    CopyrightNotice = 2,
-    SequenceOrTrackName = 3,
-    InstrumentName = 4,
-    LyricText = 5,
-    MarkerText = 6,
-    CuePoint = 7,
-    PatchName = 8,
-    PortName = 9,
-    MidiChannel = 32,
-    MidiPort = 33,
-    EndOfTrack = 47,
-    Tempo = 81,
-    SmpteOffset = 84,
-    TimeSignature = 88,
-    KeySignature = 89,
-    SequencerSpecific = 127
-}
-declare class MetaEvent extends MidiEvent {
-    get channel(): number;
-    get command(): MidiEventType;
-    get metaStatus(): MetaEventType;
-    protected constructor(track: number, delta: number, status: number, data1: number, data2: number);
-}
-
-declare class MetaDataEvent extends MetaEvent {
-    data: Uint8Array;
-    constructor(track: number, delta: number, status: number, metaId: number, data: Uint8Array);
-    writeTo(s: IWriteable): void;
-}
-
-declare class MetaNumberEvent extends MetaEvent {
-    value: number;
-    constructor(track: number, delta: number, status: number, metaId: number, value: number);
-    writeTo(s: IWriteable): void;
-}
-
-declare class Midi20PerNotePitchBendEvent extends MidiEvent {
-    noteKey: number;
-    pitch: number;
-    constructor(track: number, tick: number, status: number, noteKey: number, pitch: number);
-    /**
-     * Writes the midi event as binary into the given stream.
-     * @param s The stream to write to.
-     */
-    writeTo(s: IWriteable): void;
-}
-
-declare enum SystemCommonType {
-    SystemExclusive = 240,
-    MtcQuarterFrame = 241,
-    SongPosition = 242,
-    SongSelect = 243,
-    TuneRequest = 246,
-    SystemExclusive2 = 247
-}
-declare class SystemCommonEvent extends MidiEvent {
-    get channel(): number;
-    get command(): MidiEventType;
-    protected constructor(track: number, delta: number, status: number, data1: number, data2: number);
-}
-
-declare class SystemExclusiveEvent extends SystemCommonEvent {
-    static readonly AlphaTabManufacturerId = 125;
-    data: Uint8Array;
-    get isMetronome(): boolean;
-    get metronomeNumerator(): number;
-    get metronomeDurationInTicks(): number;
-    get metronomeDurationInMilliseconds(): number;
-    get isRest(): boolean;
-    get manufacturerId(): number;
-    constructor(track: number, delta: number, status: number, id: number, data: Uint8Array);
-    writeTo(s: IWriteable): void;
-    static encodeMetronome(counter: number, durationInTicks: number, durationInMillis: number): Uint8Array;
-}
-
 /**
  * A handler is responsible for writing midi events to a custom structure
  */
@@ -5491,7 +5639,7 @@ interface IMidiFileHandler {
      * @param controller The midi controller that should change.
      * @param value The value to which the midi controller should change
      */
-    addControlChange(track: number, tick: number, channel: number, controller: number, value: number): void;
+    addControlChange(track: number, tick: number, channel: number, controller: ControllerType, value: number): void;
     /**
      * Add a program change to the generated midi file
      * @param track The midi track on which the program should change.
@@ -5622,17 +5770,18 @@ declare class MidiFileGenerator {
  */
 declare class AlphaSynthMidiFileHandler implements IMidiFileHandler {
     private _midiFile;
+    private _smf1Mode;
     /**
      * Initializes a new instance of the {@link AlphaSynthMidiFileHandler} class.
      * @param midiFile The midi file.
+     * @param smf1Mode Whether to generate a SMF1 compatible midi file. This might break multi note bends.
      */
-    constructor(midiFile: MidiFile);
+    constructor(midiFile: MidiFile, smf1Mode?: boolean);
     addTimeSignature(tick: number, timeSignatureNumerator: number, timeSignatureDenominator: number): void;
     addRest(track: number, tick: number, channel: number): void;
     addNote(track: number, start: number, length: number, key: number, velocity: number, channel: number): void;
-    private makeCommand;
     private static fixValue;
-    addControlChange(track: number, tick: number, channel: number, controller: number, value: number): void;
+    addControlChange(track: number, tick: number, channel: number, controller: ControllerType, value: number): void;
     addProgramChange(track: number, tick: number, channel: number, program: number): void;
     addTempo(tick: number, tempo: number): void;
     addBend(track: number, tick: number, channel: number, value: number): void;
@@ -5650,28 +5799,38 @@ type index_d$3_MidiTickLookupFindBeatResult = MidiTickLookupFindBeatResult;
 declare const index_d$3_MidiTickLookupFindBeatResult: typeof MidiTickLookupFindBeatResult;
 type index_d$3_MidiFile = MidiFile;
 declare const index_d$3_MidiFile: typeof MidiFile;
+type index_d$3_MidiFileFormat = MidiFileFormat;
+declare const index_d$3_MidiFileFormat: typeof MidiFileFormat;
 type index_d$3_ControllerType = ControllerType;
 declare const index_d$3_ControllerType: typeof ControllerType;
-type index_d$3_MetaDataEvent = MetaDataEvent;
-declare const index_d$3_MetaDataEvent: typeof MetaDataEvent;
-type index_d$3_MetaEvent = MetaEvent;
-declare const index_d$3_MetaEvent: typeof MetaEvent;
-type index_d$3_MetaEventType = MetaEventType;
-declare const index_d$3_MetaEventType: typeof MetaEventType;
-type index_d$3_MetaNumberEvent = MetaNumberEvent;
-declare const index_d$3_MetaNumberEvent: typeof MetaNumberEvent;
 type index_d$3_MidiEvent = MidiEvent;
 declare const index_d$3_MidiEvent: typeof MidiEvent;
 type index_d$3_MidiEventType = MidiEventType;
 declare const index_d$3_MidiEventType: typeof MidiEventType;
-type index_d$3_Midi20PerNotePitchBendEvent = Midi20PerNotePitchBendEvent;
-declare const index_d$3_Midi20PerNotePitchBendEvent: typeof Midi20PerNotePitchBendEvent;
-type index_d$3_SystemCommonEvent = SystemCommonEvent;
-declare const index_d$3_SystemCommonEvent: typeof SystemCommonEvent;
-type index_d$3_SystemCommonType = SystemCommonType;
-declare const index_d$3_SystemCommonType: typeof SystemCommonType;
-type index_d$3_SystemExclusiveEvent = SystemExclusiveEvent;
-declare const index_d$3_SystemExclusiveEvent: typeof SystemExclusiveEvent;
+type index_d$3_TimeSignatureEvent = TimeSignatureEvent;
+declare const index_d$3_TimeSignatureEvent: typeof TimeSignatureEvent;
+type index_d$3_AlphaTabRestEvent = AlphaTabRestEvent;
+declare const index_d$3_AlphaTabRestEvent: typeof AlphaTabRestEvent;
+type index_d$3_AlphaTabMetronomeEvent = AlphaTabMetronomeEvent;
+declare const index_d$3_AlphaTabMetronomeEvent: typeof AlphaTabMetronomeEvent;
+type index_d$3_NoteEvent = NoteEvent;
+declare const index_d$3_NoteEvent: typeof NoteEvent;
+type index_d$3_NoteOnEvent = NoteOnEvent;
+declare const index_d$3_NoteOnEvent: typeof NoteOnEvent;
+type index_d$3_NoteOffEvent = NoteOffEvent;
+declare const index_d$3_NoteOffEvent: typeof NoteOffEvent;
+type index_d$3_ControlChangeEvent = ControlChangeEvent;
+declare const index_d$3_ControlChangeEvent: typeof ControlChangeEvent;
+type index_d$3_ProgramChangeEvent = ProgramChangeEvent;
+declare const index_d$3_ProgramChangeEvent: typeof ProgramChangeEvent;
+type index_d$3_TempoChangeEvent = TempoChangeEvent;
+declare const index_d$3_TempoChangeEvent: typeof TempoChangeEvent;
+type index_d$3_PitchBendEvent = PitchBendEvent;
+declare const index_d$3_PitchBendEvent: typeof PitchBendEvent;
+type index_d$3_NoteBendEvent = NoteBendEvent;
+declare const index_d$3_NoteBendEvent: typeof NoteBendEvent;
+type index_d$3_EndOfTrackEvent = EndOfTrackEvent;
+declare const index_d$3_EndOfTrackEvent: typeof EndOfTrackEvent;
 type index_d$3_MidiFileGenerator = MidiFileGenerator;
 declare const index_d$3_MidiFileGenerator: typeof MidiFileGenerator;
 type index_d$3_AlphaSynthMidiFileHandler = AlphaSynthMidiFileHandler;
@@ -5683,17 +5842,22 @@ declare namespace index_d$3 {
     index_d$3_MidiTickLookup as MidiTickLookup,
     index_d$3_MidiTickLookupFindBeatResult as MidiTickLookupFindBeatResult,
     index_d$3_MidiFile as MidiFile,
+    index_d$3_MidiFileFormat as MidiFileFormat,
     index_d$3_ControllerType as ControllerType,
-    index_d$3_MetaDataEvent as MetaDataEvent,
-    index_d$3_MetaEvent as MetaEvent,
-    index_d$3_MetaEventType as MetaEventType,
-    index_d$3_MetaNumberEvent as MetaNumberEvent,
     index_d$3_MidiEvent as MidiEvent,
     index_d$3_MidiEventType as MidiEventType,
-    index_d$3_Midi20PerNotePitchBendEvent as Midi20PerNotePitchBendEvent,
-    index_d$3_SystemCommonEvent as SystemCommonEvent,
-    index_d$3_SystemCommonType as SystemCommonType,
-    index_d$3_SystemExclusiveEvent as SystemExclusiveEvent,
+    index_d$3_TimeSignatureEvent as TimeSignatureEvent,
+    index_d$3_AlphaTabRestEvent as AlphaTabRestEvent,
+    index_d$3_AlphaTabMetronomeEvent as AlphaTabMetronomeEvent,
+    index_d$3_NoteEvent as NoteEvent,
+    index_d$3_NoteOnEvent as NoteOnEvent,
+    index_d$3_NoteOffEvent as NoteOffEvent,
+    index_d$3_ControlChangeEvent as ControlChangeEvent,
+    index_d$3_ProgramChangeEvent as ProgramChangeEvent,
+    index_d$3_TempoChangeEvent as TempoChangeEvent,
+    index_d$3_PitchBendEvent as PitchBendEvent,
+    index_d$3_NoteBendEvent as NoteBendEvent,
+    index_d$3_EndOfTrackEvent as EndOfTrackEvent,
     index_d$3_MidiFileGenerator as MidiFileGenerator,
     index_d$3_AlphaSynthMidiFileHandler as AlphaSynthMidiFileHandler,
   };
@@ -5805,21 +5969,29 @@ declare class JsonConverter {
     */
     static jsObjectToSettings(jsObject: unknown): Settings;
     /**
-     * @target web
+     * Converts the given JavaScript object into a MidiFile object.
+     * @param jsObject The javascript object to deserialize.
+     * @returns The converted MidiFile.
      */
-    static jsObjectToMidiFile(midi: any): MidiFile;
+    static jsObjectToMidiFile(jsObject: unknown): MidiFile;
     /**
-     * @target web
+     * Converts the given JavaScript object into a MidiEvent object.
+     * @param jsObject The javascript object to deserialize.
+     * @returns The converted MidiEvent.
      */
-    static jsObjectToMidiEvent(midiEvent: any): MidiEvent;
+    static jsObjectToMidiEvent(midiEvent: unknown): MidiEvent;
     /**
-     * @target web
+     * Converts the given MidiFile object into a serialized JavaScript object.
+     * @param midi The midi file to convert.
+     * @returns A serialized MidiFile object without ciruclar dependencies that can be used for further serializations.
      */
-    static midiFileToJsObject(midi: MidiFile): unknown;
+    static midiFileToJsObject(midi: MidiFile): Map<string, unknown>;
     /**
-     * @target web
+     * Converts the given MidiEvent object into a serialized JavaScript object.
+     * @param midi The midi file to convert.
+     * @returns A serialized MidiEvent object without ciruclar dependencies that can be used for further serializations.
      */
-    static midiEventToJsObject(midiEvent: MidiEvent): unknown;
+    static midiEventToJsObject(midiEvent: MidiEvent): Map<string, unknown>;
 }
 
 type index_d$2_AccentuationType = AccentuationType;