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

package/dist/types/alphatab/src/importer/alphaTex/AlphaTexShared.d.ts

@@ -0,0 +1,290 @@
+import type { AlphaTexAstNodeLocation } from "./AlphaTexAst";
+import { AlphaTexParseMode } from "./AlphaTexParser";
+import type { FlatSyncPoint } from "./../../model/Automation";
+import type { SustainPedalMarker } from "./../../model/Bar";
+import type { Beat } from "./../../model/Beat";
+import type { DynamicValue } from "./../../model/DynamicValue";
+import type { Lyrics } from "./../../model/Lyrics";
+import type { Note } from "./../../model/Note";
+import type { Score } from "./../../model/Score";
+import type { Staff } from "./../../model/Staff";
+import type { Track } from "./../../model/Track";
+/**
+ * The different severity levels for diagnostics parsing alphaTex.
+ * @public
+ */
+export declare enum AlphaTexDiagnosticsSeverity {
+    Hint = 0,
+    Warning = 1,
+    Error = 2
+}
+/**
+ * A diagnostics message for the alphaTex parser.
+ * @record
+ * @public
+ */
+export interface AlphaTexDiagnostic {
+    /**
+     * The severity of the diagnostic.
+     */
+    severity: AlphaTexDiagnosticsSeverity;
+    /**
+     * The start location to which the diagnostic message belongs.
+     */
+    start?: AlphaTexAstNodeLocation;
+    /**
+     * The end location to which the diagnostic message belongs.
+     */
+    end?: AlphaTexAstNodeLocation;
+    /**
+     * A technical code describing the diagnostic message.
+     */
+    code: AlphaTexDiagnosticCode;
+    /**
+     * The textual message for the diagnostic.
+     */
+    message: string;
+}
+/**
+ * @public
+ */
+export declare enum AlphaTexDiagnosticCode {
+    /**
+     * Unexpected character at comment start, expected '//' or '/*' but found '/%s'.
+     */
+    AT001 = 1,
+    /**
+     * Missing identifier after meta data start.
+     */
+    AT002 = 2,
+    /**
+     * Unexpected end of file. Need 4 hex characters on a \uXXXX escape sequence.
+     */
+    AT003 = 3,
+    /**
+     * Invalid unicode value. Need 4 hex characters on a \uXXXX escape sequence.
+     */
+    AT004 = 4,
+    /**
+     * Unsupported escape sequence. Expected '\n', '\r', '\t', or '\uXXXX' but found '\%s'.
+     */
+    AT005 = 5,
+    /**
+     * Unexpected end of file. String not closed.
+     */
+    AT006 = 6,
+    /**
+     * Missing beat multiplier value after '*'.
+     */
+    AT200 = 200,
+    /**
+     * Missing duration value after ':'.
+     */
+    AT201 = 201,
+    /**
+     * Unexpected '%s' token. Expected one of following: %s
+     */
+    AT202 = 202,
+    /**
+     * Unexpected end of file.
+     */
+    AT203 = 203,
+    /**
+     * Unrecognized metadata '%s'.
+     */
+    AT204 = 204,
+    /**
+     * Unrecognized property '%s'.
+     */
+    AT205 = 205,
+    /**
+     * Unexpected end of file. Group not closed.
+     */
+    AT206 = 206,
+    /**
+     * Missing string for fretted note.
+     */
+    AT207 = 207,
+    /**
+     * Note string is out of range. Available range: 1-%s
+     */
+    AT208 = 208,
+    /**
+     * Unexpected %s arguments '%s', Signature: %s
+     */
+    AT209 = 209,
+    /**
+     * Missing arguments. Expected following arguments: %s
+     */
+    AT210 = 210,
+    /**
+     * Value is out of valid range. Allowed range: %s, Actual Value: %s
+     */
+    AT211 = 211,
+    /**
+     * Unrecogized property '%s', expected one of %s
+     */
+    AT212 = 212,
+    /**
+     * Invalid format for color
+     */
+    AT213 = 213,
+    /**
+     * The '%s' effect needs %s arguments per item. With %s points, %s arguments are needed, only %s arguments found.
+     */
+    AT214 = 214,
+    /**
+     * Cannot use pitched note value '%s' on %s staff, please specify notes using the 'fret.string' syntax.
+     */
+    AT215 = 215,
+    /**
+     * Cannot use pitched note value '%s' on percussion staff, please specify percussion articulations with numbers or names.
+     */
+    AT216 = 216,
+    /**
+     * Unrecognized note value '%s'.
+     */
+    AT217 = 217,
+    /**
+     * Wrong note kind '%s' for staff with note kind '%s'. Do not mix incompatible staves and notes.
+     */
+    AT218 = 218,
+    /**
+     * Error parsing arguments: no overload matched arguments %s. Signatures: %s
+     */
+    AT219 = 219,
+    /**
+     * Error parsing arguments: unexpected additional arguments. Signatures: %s
+     */
+    AT220 = 220,
+    /**
+     * Expected no arguments, but found some.
+     */
+    AT300 = 300,
+    /**
+     * Metadata arguments should be wrapped into parenthesis.
+     */
+    AT301 = 301,
+    /**
+     * Metadata arguments should be placed before metadata properties.
+     */
+    AT302 = 302,
+    /**
+     * Property arguments should be wrapped into parenthesis.
+     */
+    AT303 = 303,
+    /**
+     * The beat multiplier should be specified after the beat effects.
+     */
+    AT304 = 304,
+    /**
+     * This value should be rather specified via the properties.
+     */
+    AT305 = 305,
+    /**
+     * This staff metadata tag should be specified as staff property.
+     */
+    AT306 = 306,
+    /**
+     * The dots separating score metadata, score contents and the sync points can be removed.
+     */
+    AT400 = 400
+}
+/**
+ * @public
+ */
+export declare class AlphaTexDiagnosticBag implements Iterable<AlphaTexDiagnostic> {
+    private _hasErrors;
+    readonly items: AlphaTexDiagnostic[];
+    get errors(): AlphaTexDiagnostic[];
+    get hasErrors(): boolean;
+    push(diagnostic: AlphaTexDiagnostic): void;
+    [Symbol.iterator](): Iterator<AlphaTexDiagnostic>;
+}
+/**
+ * @public
+ */
+export declare enum AlphaTexAccidentalMode {
+    Auto = 0,
+    Explicit = 1
+}
+/**
+ * @public
+ */
+export interface IAlphaTexImporterState {
+    score: Score;
+    accidentalMode: AlphaTexAccidentalMode;
+    currentDynamics: DynamicValue;
+    currentTupletNumerator: number;
+    currentTupletDenominator: number;
+    readonly syncPoints: FlatSyncPoint[];
+    readonly slurs: Map<string, Note>;
+    readonly percussionArticulationNames: Map<string, number>;
+    readonly lyrics: Map<number, Lyrics[]>;
+    readonly staffHasExplicitDisplayTransposition: Set<Staff>;
+    readonly staffHasExplicitTuning: Set<Staff>;
+    readonly staffTuningApplied: Set<Staff>;
+    readonly sustainPedalToBeat: Map<SustainPedalMarker, Beat>;
+}
+/**
+ * Lists the note kinds we can detect
+ * @public
+ */
+export declare enum AlphaTexStaffNoteKind {
+    Pitched = 0,
+    Fretted = 1,
+    Articulation = 2
+}
+/**
+ * @public
+ */
+export interface IAlphaTexImporter {
+    readonly state: IAlphaTexImporterState;
+    readonly parseMode: AlphaTexParseMode;
+    applyStaffNoteKind(staff: Staff, staffNoteKind: AlphaTexStaffNoteKind): void;
+    startNewVoice(): void;
+    startNewTrack(): Track;
+    startNewStaff(): Staff;
+    addSemanticDiagnostic(diagnostic: AlphaTexDiagnostic): void;
+}
+/**
+ * Defines how the arguments of the meta data tag is parsed.
+ * @public
+ */
+export declare enum ArgumentListParseTypesMode {
+    /**
+     * Indicates that the parameter of the given types is required.
+     * If the token matches, it is added to the value list.
+     * If the token does not match, an error diagnostic is added and parsing is stopped.
+     */
+    Required = 0,
+    /**
+     * Indicates that the parameter of the given types is optional.
+     * If the token matches, it is added to the value list.
+     * If the token does not match, the value list completes and parsing continues.
+     */
+    Optional = 1,
+    /**
+     * Same as {@link Required} but the next argument is interpreted as a float.
+     */
+    RequiredAsFloat = 2,
+    /**
+     * Same as {@link Optional} but the next argument is interpreted as a float.
+     */
+    OptionalAsFloat = 3,
+    /**
+     * Indicates that multiple arguments of the same types should be parsed as a list
+     * Think: rest-parameter that allows parameters to follow if the type doesn't match anymore.
+     * If the token is a open parenthesis, it starts reading the specified types as value list. If an unexpected item is
+     * encountered an error diagnostic is added.
+     * If the token matches the expected type, a single value is read.
+     * If the token is any other type, an error diagnostic is added and parsing is stopped.
+     */
+    RequiredAsValueList = 4,
+    /**
+     * Indicates that multiple parameters of the same types should be parsed. (this is mainly for backwards compatibility with older alphaTex files)
+     * If the token matches, it is added to the value list. Parsing stays on the current type.
+     * If the token does not match, the value list completes and parsing continues.
+     */
+    ValueListWithoutParenthesis = 5
+}

package/dist/types/alphatab/src/importer/alphaTex/IAlphaTexLanguageImportHandler.d.ts

@@ -0,0 +1,50 @@
+import type { AlphaTexMetaDataNode, AlphaTexPropertyNode } from "./AlphaTexAst";
+import type { IAlphaTexImporter } from "./AlphaTexShared";
+import type { Bar } from "./../../model/Bar";
+import type { Beat } from "./../../model/Beat";
+import type { Note } from "./../../model/Note";
+import type { Score } from "./../../model/Score";
+import type { Staff } from "./../../model/Staff";
+/**
+ * @internal
+ */
+export declare enum ApplyNodeResult {
+    Applied = 0,
+    NotAppliedSemanticError = 1,
+    NotAppliedUnrecognizedMarker = 2
+}
+/**
+ * @internal
+ */
+export declare enum ApplyStructuralMetaDataResult {
+    AppliedNewTrack = 0,
+    AppliedNewStaff = 1,
+    AppliedNewVoice = 2,
+    NotAppliedSemanticError = 3,
+    NotAppliedUnrecognizedMarker = 4
+}
+/**
+ * @internal
+ */
+export interface IAlphaTexLanguageImportHandler {
+    applyStructuralMetaData(importer: IAlphaTexImporter, metaData: AlphaTexMetaDataNode): ApplyStructuralMetaDataResult;
+    applyScoreMetaData(importer: IAlphaTexImporter, score: Score, metaData: AlphaTexMetaDataNode): ApplyNodeResult;
+    applyStaffMetaData(importer: IAlphaTexImporter, staff: Staff, metaData: AlphaTexMetaDataNode): ApplyNodeResult;
+    applyBarMetaData(importer: IAlphaTexImporter, bar: Bar, metaData: AlphaTexMetaDataNode): ApplyNodeResult;
+    applyBeatDurationProperty(importer: IAlphaTexImporter, property: AlphaTexPropertyNode): ApplyNodeResult;
+    applyBeatProperty(importer: IAlphaTexImporter, beat: Beat, property: AlphaTexPropertyNode): ApplyNodeResult;
+    applyNoteProperty(importer: IAlphaTexImporter, note: Note, p: AlphaTexPropertyNode): ApplyNodeResult;
+    readonly allKnownMetaDataTags: Set<string>;
+    readonly knownScoreMetaDataTags: Set<string>;
+    readonly knownStructuralMetaDataTags: Set<string>;
+    readonly knownStaffMetaDataTags: Set<string>;
+    readonly knownBarMetaDataTags: Set<string>;
+    readonly knownBeatProperties: Set<string>;
+    readonly knownBeatDurationProperties: Set<string>;
+    readonly knownNoteProperties: Set<string>;
+    buildScoreMetaDataNodes(score: Score): AlphaTexMetaDataNode[];
+    buildBarMetaDataNodes(staff: Staff, bar: Bar | undefined, voice: number, isMultiVoice: boolean): AlphaTexMetaDataNode[];
+    buildSyncPointNodes(score: Score): AlphaTexMetaDataNode[];
+    buildBeatEffects(beat: Beat): AlphaTexPropertyNode[];
+    buildNoteEffects(data: Note): AlphaTexPropertyNode[];
+}

package/dist/types/alphatab/src/importer/alphaTex/IAlphaTexMetaDataReader.d.ts

@@ -0,0 +1,12 @@
+import type { AlphaTexMetaDataTagNode, AlphaTexPropertyNode, AlphaTexArgumentList } from "./AlphaTexAst";
+import type { AlphaTexParser } from "./AlphaTexParser";
+/**
+ * @internal
+ */
+export interface IAlphaTexMetaDataReader {
+    readMetaDataArguments(parser: AlphaTexParser, metaData: AlphaTexMetaDataTagNode): AlphaTexArgumentList | undefined;
+    readMetaDataPropertyArguments(parser: AlphaTexParser, metaData: AlphaTexMetaDataTagNode, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
+    readBeatPropertyArguments(parser: AlphaTexParser, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
+    readDurationChangePropertyArguments(parser: AlphaTexParser, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
+    readNotePropertyArguments(parser: AlphaTexParser, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
+}

package/dist/types/alphatab/src/importer/alphaTex/_barrel.d.ts

@@ -0,0 +1,4 @@
+export { type AlphaTexArgumentList, type AlphaTexAsteriskTokenNode, type AlphaTexAstNode, type AlphaTexAstNodeLocation, type AlphaTexBackSlashTokenNode, type AlphaTexBarNode, type AlphaTexBeatDurationChangeNode, type AlphaTexBeatNode, type AlphaTexBraceCloseTokenNode, type AlphaTexBraceOpenTokenNode, type AlphaTexColonTokenNode, type AlphaTexComment, type AlphaTexDotTokenNode, type AlphaTexDoubleBackSlashTokenNode, type AlphaTexIdentifier, type AlphaTexMetaDataNode, type AlphaTexMetaDataTagNode, AlphaTexNodeType, type AlphaTexNoteListNode, type AlphaTexNoteNode, type AlphaTexNumberLiteral, type AlphaTexParenthesisCloseTokenNode, type AlphaTexParenthesisOpenTokenNode, type AlphaTexPipeTokenNode, type AlphaTexPropertiesNode, type AlphaTexPropertyNode, type AlphaTexScoreNode, type AlphaTexStringLiteral, type AlphaTexTextNode, type AlphaTexTokenNode, type IAlphaTexArgumentValue, type IAlphaTexAstNode, type IAlphaTexMetaDataTagPrefixNode, type IAlphaTexNoteValueNode } from "./AlphaTexAst";
+export { AlphaTexLexer } from "./AlphaTexLexer";
+export { AlphaTexParseMode, AlphaTexParser } from "./AlphaTexParser";
+export { AlphaTexAccidentalMode, type AlphaTexDiagnostic, AlphaTexDiagnosticBag, AlphaTexDiagnosticCode, AlphaTexDiagnosticsSeverity, AlphaTexStaffNoteKind, ArgumentListParseTypesMode, type IAlphaTexImporter, type IAlphaTexImporterState } from "./AlphaTexShared";

package/dist/types/alphatab/src/io/BitReader.d.ts

@@ -0,0 +1,18 @@
+import { type IReadable } from "./IReadable";
+/**
+ * This utility public class allows bitwise reading of a stream
+ * @internal
+ */
+export declare class BitReader {
+    private static readonly _byteSize;
+    private _currentByte;
+    private _position;
+    private _source;
+    constructor(source: IReadable);
+    readByte(): number;
+    readBytes(count: number): Uint8Array;
+    readBits(count: number): number;
+    readBitsReversed(count: number): number;
+    readBit(): number;
+    readAll(): Uint8Array;
+}

package/dist/types/alphatab/src/io/ByteBuffer.d.ts

@@ -0,0 +1,26 @@
+import type { IReadable } from "./IReadable";
+import type { IWriteable } from "./IWriteable";
+/**
+ * @public
+ */
+export declare class ByteBuffer implements IWriteable, IReadable {
+    private _buffer;
+    length: number;
+    position: number;
+    get bytesWritten(): number;
+    getBuffer(): Uint8Array;
+    static empty(): ByteBuffer;
+    static withCapacity(capacity: number): ByteBuffer;
+    static fromBuffer(data: Uint8Array): ByteBuffer;
+    static fromString(contents: string): ByteBuffer;
+    reset(): void;
+    skip(offset: number): void;
+    readByte(): number;
+    read(buffer: Uint8Array, offset: number, count: number): number;
+    writeByte(value: number): void;
+    write(buffer: Uint8Array, offset: number, count: number): void;
+    private _ensureCapacity;
+    readAll(): Uint8Array;
+    toArray(): Uint8Array;
+    copyTo(destination: IWriteable): void;
+}

package/dist/types/alphatab/src/io/IOHelper.d.ts

@@ -0,0 +1,38 @@
+import type { IReadable } from "./IReadable";
+import type { IWriteable } from "./IWriteable";
+/**
+ * @public
+ */
+export declare class IOHelper {
+    static readInt32BE(input: IReadable): number;
+    static readFloat32BE(readable: IReadable): number;
+    static readFloat64BE(readable: IReadable): number;
+    static readInt32LE(input: IReadable): number;
+    static readInt64LE(input: IReadable): number;
+    static readUInt32LE(input: IReadable): number;
+    static decodeUInt32LE(data: Uint8Array, index: number): number;
+    static readUInt16LE(input: IReadable): number;
+    static readInt16LE(input: IReadable): number;
+    static readUInt32BE(input: IReadable): number;
+    static readUInt16BE(input: IReadable): number;
+    static readInt16BE(input: IReadable): number;
+    static readByteArray(input: IReadable, length: number): Uint8Array;
+    static read8BitChars(input: IReadable, length: number): string;
+    static read8BitString(input: IReadable): string;
+    static read8BitStringLength(input: IReadable, length: number): string;
+    static readSInt8(input: IReadable): number;
+    static readInt24(input: Uint8Array, index: number): number;
+    static readInt16(input: Uint8Array, index: number): number;
+    static toString(data: Uint8Array, encoding: string): string;
+    private static _detectEncoding;
+    static stringToBytes(str: string): Uint8Array;
+    static writeInt32BE(o: IWriteable, v: number): void;
+    static writeInt32LE(o: IWriteable, v: number): void;
+    static writeUInt16LE(o: IWriteable, v: number): void;
+    static writeInt16LE(o: IWriteable, v: number): void;
+    static writeInt16BE(o: IWriteable, v: number): void;
+    static writeFloat32BE(o: IWriteable, v: number): void;
+    static iterateCodepoints(input: string): Generator<number, void, unknown>;
+    static isLeadingSurrogate(charCode: number): boolean;
+    static isTrailingSurrogate(charCode: number): boolean;
+}

package/dist/types/alphatab/src/io/IReadable.d.ts

@@ -0,0 +1,48 @@
+import { AlphaTabError } from "./../AlphaTabError";
+/**
+ * Represents a stream of binary data that can be read from.
+ * @public
+ */
+export interface IReadable {
+    /**
+     * Gets or sets the current read position relative in the stream.
+     */
+    position: number;
+    /**
+     * Gets the total number of bytes contained in the stream.
+     */
+    readonly length: number;
+    /**
+     * Resets the stream for reading the data from the beginning.
+     */
+    reset(): void;
+    /**
+     * Skip the given number of bytes.
+     * @param offset The number of bytes to skip.
+     */
+    skip(offset: number): void;
+    /**
+     * Read a single byte from the data stream.
+     * @returns The value of the next byte or -1 if there is no more data.
+     */
+    readByte(): number;
+    /**
+     * Reads the given number of bytes from the stream into the given buffer.
+     * @param buffer The buffer to fill.
+     * @param offset The offset in the buffer where to start writing.
+     * @param count The number of bytes to read.
+     * @returns
+     */
+    read(buffer: Uint8Array, offset: number, count: number): number;
+    /**
+     * Reads the remaining data.
+     * @returns
+     */
+    readAll(): Uint8Array;
+}
+/**
+ * @internal
+ */
+export declare class EndOfReaderError extends AlphaTabError {
+    constructor();
+}

package/dist/types/alphatab/src/io/IWriteable.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Represents a writer where binary data can be written to.
+ * @public
+ */
+export interface IWriteable {
+    /**
+     * Gets the current number of written bytes.
+     */
+    readonly bytesWritten: number;
+    /**
+     * Write a single byte to the stream.
+     * @param value The value to write.
+     */
+    writeByte(value: number): void;
+    /**
+     * Write data from the given buffer.
+     * @param buffer The buffer to get the data from.
+     * @param offset The offset where to start reading the data.
+     * @param count The number of bytes to write
+     */
+    write(buffer: Uint8Array, offset: number, count: number): void;
+}

package/dist/types/alphatab/src/io/JsonHelper.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @partial
+ * @internal
+ */
+export declare class JsonHelper {
+    /**
+     * @target web
+     * @partial
+     */
+    static parseEnum<T>(s: unknown, enumType: any): T | undefined;
+    /**
+     * @target web
+     * @partial
+     */
+    static parseEnumExact<T>(s: string, enumType: any): T | undefined;
+    /**
+     * @target web
+     * @partial
+     */
+    static forEach(s: unknown, func: (v: unknown, k: string) => void): void;
+    /**
+     * @target web
+     * @partial
+     */
+    static getValue(s: unknown, key: string): unknown;
+}

package/dist/types/alphatab/src/io/TypeConversions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @target web
+ * @internal
+ */
+export declare class TypeConversions {
+    private static readonly _conversionBuffer;
+    private static readonly _conversionByteArray;
+    private static readonly _dataView;
+    static float64ToBytes(v: number): Uint8Array;
+    static bytesToInt64LE(bytes: Uint8Array): number;
+    static bytesToFloat64LE(bytes: Uint8Array): number;
+    static bytesToFloat32LE(bytes: Uint8Array): number;
+    static float32BEToBytes(v: number): Uint8Array;
+    static uint16ToInt16(v: number): number;
+    static int16ToUint32(v: number): number;
+    static int32ToUint16(v: number): number;
+    static int32ToInt16(v: number): number;
+    static int32ToUint32(v: number): number;
+    static uint8ToInt8(v: number): number;
+}

package/dist/types/alphatab/src/io/_barrel.d.ts

@@ -0,0 +1,4 @@
+export type { IWriteable } from "./IWriteable";
+export type { IReadable } from "./IReadable";
+export { ByteBuffer } from "./ByteBuffer";
+export { IOHelper } from "./IOHelper";

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

@@ -0,0 +1,28 @@
+import type { IMidiFileHandler } from "./IMidiFileHandler";
+import { type MidiFile } from "./MidiFile";
+import type { ControllerType } from "./ControllerType";
+/**
+ * This implementation of the {@link IMidiFileHandler}
+ * generates a {@link MidiFile} object which can be used in AlphaSynth for playback.
+ * @public
+ */
+export 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, 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 static _fixValue;
+    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;
+    addNoteBend(track: number, tick: number, channel: number, key: number, value: number): void;
+    finishTrack(track: number, tick: number): void;
+}

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

@@ -0,0 +1,63 @@
+import type { Beat } from "./../model/Beat";
+/**
+ * Represents a beat and when it is actually played according to the generated audio.
+ * @public
+ */
+export declare class BeatTickLookupItem {
+    /**
+     * Gets the beat represented by this item.
+     */
+    readonly beat: Beat;
+    /**
+     * Gets the playback start of the beat according to the generated audio.
+     */
+    readonly playbackStart: number;
+    constructor(beat: Beat, playbackStart: number);
+}
+/**
+ * Represents the time period, for which one or multiple {@link Beat}s are played
+ * @public
+ */
+export declare class BeatTickLookup {
+    private _highlightedBeats;
+    /**
+     * Gets or sets the start time in midi ticks at which the given beat is played.
+     */
+    start: number;
+    /**
+     * Gets or sets the end time in midi ticks at which the given beat is played.
+     */
+    end: number;
+    /**
+     * Gets or sets a list of all beats that should be highlighted when
+     * the beat of this lookup starts playing. This might not mean
+     * the beats start at this position.
+     */
+    highlightedBeats: BeatTickLookupItem[];
+    /**
+     * Gets the next BeatTickLookup which comes after this one and is in the same
+     * MasterBarTickLookup.
+     */
+    nextBeat: BeatTickLookup | null;
+    /**
+     * Gets the preivous BeatTickLookup which comes before this one and is in the same
+     * MasterBarTickLookup.
+     */
+    previousBeat: BeatTickLookup | null;
+    /**
+     * Gets the tick duration of this lookup.
+     */
+    get duration(): number;
+    constructor(start: number, end: number);
+    /**
+     * Marks the given beat as highlighed as part of this lookup.
+     * @param beat The beat to add.
+     */
+    highlightBeat(beat: Beat, playbackStart: number): void;
+    /**
+     * Looks for the first visible beat which starts at this lookup so it can be used for cursor placement.
+     * @param visibleTracks The visible tracks.
+     * @returns The first beat which is visible according to the given tracks or null.
+     */
+    getVisibleBeatAtStart(visibleTracks: Set<number>): Beat | null;
+}