@coderline/alphatab-language-server 1.7.0-alpha.1626

package/dist/types/alphatab/src/midi/ControllerType.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Lists all midi controllers.
+ * @public
+ */
+export 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,
+    BankSelectFine = 32,
+    /**
+     * 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,
+    AllSoundOff = 120,
+    /**
+     * Reset all controllers
+     */
+    ResetControllers = 121,
+    /**
+     * All notes of.
+     */
+    AllNotesOff = 123
+}

package/dist/types/alphatab/src/midi/DeprecatedEvents.d.ts

@@ -0,0 +1,103 @@
+import type { IWriteable } from "./../io/IWriteable";
+import { MidiEvent } from "./MidiEvent";
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export declare class DeprecatedMidiEvent extends MidiEvent {
+    constructor();
+    writeTo(_s: IWriteable): void;
+}
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export 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
+}
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export declare class MetaEvent extends DeprecatedMidiEvent {
+    get metaStatus(): MetaEventType;
+}
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export declare class MetaDataEvent extends MetaEvent {
+    data: Uint8Array;
+}
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export declare class MetaNumberEvent extends MetaEvent {
+    value: number;
+}
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export declare class Midi20PerNotePitchBendEvent extends DeprecatedMidiEvent {
+    noteKey: number;
+    pitch: number;
+}
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export declare enum SystemCommonType {
+    SystemExclusive = 240,
+    MtcQuarterFrame = 241,
+    SongPosition = 242,
+    SongSelect = 243,
+    TuneRequest = 246,
+    SystemExclusive2 = 247
+}
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export declare class SystemCommonEvent extends DeprecatedMidiEvent {
+}
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export declare enum AlphaTabSystemExclusiveEvents {
+    MetronomeTick = 0,
+    Rest = 1
+}
+/**
+ * @deprecated Move to the new concrete Midi Event Types.
+ * @public
+ */
+export 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;
+}

package/dist/types/alphatab/src/midi/GeneralMidi.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This public class provides names for all general midi instruments.
+ * @internal
+ */
+export declare class GeneralMidi {
+    private static _values;
+    static getValue(name: string): number;
+    static getName(input: number): string;
+    static isPiano(program: number): boolean;
+    static isGuitar(program: number): boolean;
+    static isBass(program: number): boolean;
+    static bankToLsbMsb(bank: number): [number, number];
+}

package/dist/types/alphatab/src/midi/IMidiFileHandler.d.ts

@@ -0,0 +1,79 @@
+import type { ControllerType } from "./ControllerType";
+/**
+ * A handler is responsible for writing midi events to a custom structure
+ * @public
+ */
+export interface IMidiFileHandler {
+    /**
+     * Adds a time signature to the generated midi file
+     * @param tick The midi ticks when this event should be happening.
+     * @param timeSignatureNumerator The time signature numerator
+     * @param timeSignatureDenominator The time signature denominator
+     */
+    addTimeSignature(tick: number, timeSignatureNumerator: number, timeSignatureDenominator: number): void;
+    /**
+     * Adds a rest to the generated midi file.
+     * @param track The midi track on which the rest should be "played".
+     * @param tick The midi ticks when the rest is "playing".
+     * @param channel The midi channel on which the rest should be "played".
+     */
+    addRest(track: number, tick: number, channel: number): void;
+    /**
+     * Adds a note to the generated midi file
+     * @param track The midi track on which the note should be played.
+     * @param start The midi ticks when the note should start playing.
+     * @param length The duration the note in midi ticks.
+     * @param key The key of the note to play
+     * @param velocity The velocity which should be applied to the note (derived from the note dynamics).
+     * @param channel The midi channel on which the note should be played.
+     */
+    addNote(track: number, start: number, length: number, key: number, velocity: number, channel: number): void;
+    /**
+     * Adds a control change to the generated midi file.
+     * @param track The midi track on which the controller should change.
+     * @param tick The midi ticks when the controller should change.
+     * @param channel The midi channel on which the controller should change.
+     * @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: ControllerType, value: number): void;
+    /**
+     * Add a program change to the generated midi file
+     * @param track The midi track on which the program should change.
+     * @param tick The midi ticks when the program should change.
+     * @param channel The midi channel on which the program should change.
+     * @param program The new program for the selected track and channel.
+     */
+    addProgramChange(track: number, tick: number, channel: number, program: number): void;
+    /**
+     * Add a tempo change to the generated midi file.
+     * @param tick The midi ticks when the tempo should change change.
+     * @param tempo The tempo as BPM
+     */
+    addTempo(tick: number, tempo: number): void;
+    /**
+     * Add a bend specific to a note to the generated midi file.
+     * The note does not need to be started, if this event is signaled, the next time a note
+     * on this channel and key is played it will be affected. The note bend is cleared on a note-off for this key.
+     * @param track The midi track on which the bend should change.
+     * @param tick The midi ticks when the bend should change.
+     * @param channel The midi channel on which the bend should change.
+     * @param channel The key of the note that should be affected by the bend.
+     * @param value The new bend for the selected note.
+     */
+    addNoteBend(track: number, tick: number, channel: number, key: number, value: number): void;
+    /**
+     * Add a bend to the generated midi file.
+     * @param track The midi track on which the bend should change.
+     * @param tick The midi ticks when the bend should change.
+     * @param channel The midi channel on which the bend should change.
+     * @param value The new bend for the selected track and channel.
+     */
+    addBend(track: number, tick: number, channel: number, value: number): void;
+    /**
+     * Indicates that the track is finished on the given ticks.
+     * @param track The track that was finished.
+     * @param tick The end tick for this track.
+     */
+    finishTrack(track: number, tick: number): void;
+}

package/dist/types/alphatab/src/midi/MasterBarTickLookup.d.ts

@@ -0,0 +1,85 @@
+import { BeatTickLookup } from "./BeatTickLookup";
+import type { Beat } from "./../model/Beat";
+import type { MasterBar } from "./../model/MasterBar";
+/**
+ * Represents a single point in time defining the tempo of a {@link MasterBarTickLookup}.
+ * This is typically the initial tempo of a master bar or a tempo change.
+ * @public
+ */
+export declare class MasterBarTickLookupTempoChange {
+    /**
+     * Gets or sets the tick position within the {@link MasterBarTickLookup.start} and  {@link MasterBarTickLookup.end} range.
+     */
+    tick: number;
+    /**
+     * Gets or sets the tempo at the tick position.
+     */
+    tempo: number;
+    constructor(tick: number, tempo: number);
+}
+/**
+ * Represents the time period, for which all bars of a {@link MasterBar} are played.
+ * @public
+ */
+export declare class MasterBarTickLookup {
+    /**
+     * Gets or sets the start time in midi ticks at which the MasterBar is played.
+     */
+    start: number;
+    /**
+     * Gets or sets the end time in midi ticks at which the MasterBar is played.
+     */
+    end: number;
+    /**
+     * Gets or sets the current tempo when the MasterBar is played.
+     * @deprecated use {@link tempoChanges}
+     */
+    get tempo(): number;
+    /**
+     * Gets the list of tempo changes within the tick lookup.
+     */
+    readonly tempoChanges: MasterBarTickLookupTempoChange[];
+    /**
+     * Gets or sets the MasterBar which is played.
+     */
+    masterBar: MasterBar;
+    /**
+     * The first beat in the bar.
+     */
+    firstBeat: BeatTickLookup | null;
+    /**
+     * The last beat in the bar.
+     */
+    lastBeat: BeatTickLookup | null;
+    /**
+     * Inserts `newNextBeat` after `currentBeat` in the linked list of items and updates.
+     * the `firstBeat` and `lastBeat` respectively too.
+     * @param currentBeat The item in which to insert the new item afterwards
+     * @param newBeat The new item to insert
+     */
+    private _insertAfter;
+    /**
+     * Inserts `newNextBeat` before `currentBeat` in the linked list of items and updates.
+     * the `firstBeat` and `lastBeat` respectively too.
+     * @param currentBeat The item in which to insert the new item afterwards
+     * @param newBeat The new item to insert
+     */
+    private _insertBefore;
+    /**
+     * Gets or sets the {@link MasterBarTickLookup} of the next masterbar in the {@link Score}
+     */
+    nextMasterBar: MasterBarTickLookup | null;
+    /**
+     * Gets or sets the {@link MasterBarTickLookup} of the previous masterbar in the {@link Score}
+     */
+    previousMasterBar: MasterBarTickLookup | null;
+    /**
+     * Adds a new beat to this masterbar following the slicing logic required by the MidiTickLookup.
+     * @param beat The beat to add to this masterbat
+     * @param beatPlaybackStart The original start of this beat. This time is relevant for highlighting.
+     * @param sliceStart The slice start to which this beat should be added. This time is relevant for creating new slices.
+     * @param sliceDuration The slice duration to which this beat should be added. This time is relevant for creating new slices.
+     * @returns The first item of the chain which was affected.
+     */
+    addBeat(beat: Beat, beatPlaybackStart: number, sliceStart: number, sliceDuration: number): void;
+}

package/dist/types/alphatab/src/midi/MidiEvent.d.ts

@@ -0,0 +1,292 @@
+import type { IWriteable } from "./../io/IWriteable";
+import type { ControllerType } from "./ControllerType";
+/**
+ * Lists all midi event types. Based on the type the instance is a specific subclass.
+ * @public
+ */
+export declare enum MidiEventType {
+    TimeSignature = 88,// 0xFF _0x58_ in Midi 1.0
+    NoteOn = 128,// Aligned with Midi 1.0
+    NoteOff = 144,// Aligned with Midi 1.0
+    ControlChange = 176,// Aligned with Midi 1.0
+    ProgramChange = 192,// Aligned with Midi 1.0
+    TempoChange = 81,// 0xFF _0x51_ in Midi 1.0
+    PitchBend = 224,// Aligned with Midi 1.0
+    PerNotePitchBend = 96,// Aligned with Midi 2.0
+    EndOfTrack = 47,// 0xFF _0x2F_ in Midi 1.0
+    AlphaTabRest = 241,// SystemExclusive + 1
+    AlphaTabMetronome = 242,// SystemExclusive + 2
+    /**
+     * @deprecated Not used anymore internally. move to the other concrete types.
+     */
+    SystemExclusive = 240,// Aligned with Midi 1.0
+    /**
+     * @deprecated Not used anymore internally. move to the other concrete types.
+     */
+    SystemExclusive2 = 247,// Aligned with Midi 1.0
+    /**
+     * @deprecated Not used anymore internally. move to the other concrete types.
+     */
+    Meta = 255
+}
+/**
+ * Represents a midi event.
+ * @public
+ */
+export declare abstract class MidiEvent {
+    /**
+     * Gets or sets the track to which the midi event belongs.
+     */
+    track: number;
+    /**
+     * Gets or sets the absolute tick of this midi event.
+     */
+    tick: 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 command The type of this event.
+     */
+    constructor(track: number, tick: number, command: MidiEventType);
+    /**
+     * @deprecated Change to `type`
+     */
+    get command(): MidiEventType;
+    /**
+     * The 32-bit encoded raw midi message. Deprecated {@since 1.3.0}. Use the properties of the subclasses instead.
+     * @deprecated Use individual properties to access data.
+     */
+    get message(): number;
+    /**
+     * The first data byte. Meaning depends on midi event type. (Deprecated {@since 1.3.0}, use the specific properties of the midi event depending on type)
+     * @deprecated Use individual properties to access data.
+     */
+    get data1(): number;
+    /**
+     * The second data byte Meaning depends on midi event type. (Deprecated {@since 1.3.0}, use the specific properties of the midi event depending on type)
+     * @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.
+ * @public
+ */
+export 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).
+ * @public
+ */
+export declare abstract class AlphaTabSysExEvent extends MidiEvent {
+    static readonly AlphaTabManufacturerId = 125;
+    static readonly MetronomeEventId = 0;
+    static readonly RestEventId = 1;
+    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.
+ * @public
+ */
+export 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.
+ * @public
+ */
+export 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.
+ * @public
+ */
+export 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
+ * @public
+ */
+export 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.
+ * @public
+ */
+export 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.
+ * @public
+ */
+export 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.
+ * @public
+ */
+export 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.
+ * @public
+ */
+export declare class TempoChangeEvent extends MidiEvent {
+    /**
+     * The tempo in microseconds per quarter note (aka USQ). A time format typically for midi.
+     */
+    get microSecondsPerQuarterNote(): number;
+    /**
+         * The tempo in microseconds per quarter note (aka USQ). A time format typically for midi.
+         */
+    set microSecondsPerQuarterNote(value: number);
+    /**
+     * The tempo in beats per minute
+     */
+    beatsPerMinute: number;
+    constructor(tick: number, microSecondsPerQuarterNote: number);
+    writeTo(s: IWriteable): void;
+}
+/**
+ * Represents a change of the pitch bend (aka. pitch wheel) on a specific channel.
+ * @public
+ */
+export 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.
+ * @public
+ */
+export 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.
+ * @public
+ */
+export declare class EndOfTrackEvent extends MidiEvent {
+    constructor(track: number, tick: number);
+    writeTo(s: IWriteable): void;
+}