@coderline/alphatab-monaco 1.7.0-alpha.1626 → 1.7.0-alpha.1628

package/dist/types/alphatab/src/rendering/layout/ScoreLayout.d.ts

@@ -1,73 +0,0 @@
-import type { Bar } from "./../../model/Bar";
-import { ScoreSubElement } from "./../../model/Score";
-import { type ICanvas } from "./../../platform/ICanvas";
-import { BarRendererBase } from "./../BarRendererBase";
-import { ChordDiagramContainerGlyph } from "./../glyphs/ChordDiagramContainerGlyph";
-import { TextGlyph } from "./../glyphs/TextGlyph";
-import { RenderFinishedEventArgs } from "./../RenderFinishedEventArgs";
-import type { ScoreRenderer } from "./../ScoreRenderer";
-import { StaffSystem } from "./../staves/StaffSystem";
-import { NotationElement } from "./../../NotationSettings";
-import { TuningContainerGlyph } from "./../glyphs/TuningContainerGlyph";
-import { Lazy } from "./../../util/Lazy";
-/**
- * Lists the different modes in which the staves and systems are arranged.
- * @internal
- */
-export declare enum InternalSystemsLayoutMode {
-    /**
-     * Use the automatic alignment system provided by alphaTab (default)
-     */
-    Automatic = 0,
-    /**
-     * Use the relative scaling information stored in the score model.
-     */
-    FromModelWithScale = 1,
-    /**
-     * Use the absolute size information stored in the score model.
-     */
-    FromModelWithWidths = 2
-}
-/**
- * This is the base class for creating new layouting engines for the score renderer.
- * @internal
- */
-export declare abstract class ScoreLayout {
-    private _barRendererLookup;
-    protected pagePadding: number[] | null;
-    abstract get name(): string;
-    renderer: ScoreRenderer;
-    width: number;
-    height: number;
-    multiBarRestInfo: Map<number, number[]> | null;
-    get scaledWidth(): number;
-    protected headerGlyphs: Map<ScoreSubElement, TextGlyph>;
-    protected footerGlyphs: Map<ScoreSubElement, TextGlyph>;
-    protected chordDiagrams: ChordDiagramContainerGlyph | null;
-    protected tuningGlyph: TuningContainerGlyph | null;
-    systemsLayoutMode: InternalSystemsLayoutMode;
-    constructor(renderer: ScoreRenderer);
-    abstract get firstBarX(): number;
-    abstract get supportsResize(): boolean;
-    resize(): void;
-    abstract doResize(): void;
-    layoutAndRender(): void;
-    private _lazyPartials;
-    protected registerPartial(args: RenderFinishedEventArgs, callback: (canvas: ICanvas) => void): void;
-    private _internalRenderLazyPartial;
-    renderLazyPartial(resultId: string): void;
-    protected abstract doLayoutAndRender(): void;
-    protected static readonly headerElements: Lazy<Map<ScoreSubElement, NotationElement | undefined>>;
-    protected static readonly footerElements: Lazy<Map<ScoreSubElement, NotationElement | undefined>>;
-    private _createHeaderFooterGlyph;
-    private _createScoreInfoGlyphs;
-    firstBarIndex: number;
-    lastBarIndex: number;
-    protected createEmptyStaffSystem(): StaffSystem;
-    registerBarRenderer(key: string, renderer: BarRendererBase): void;
-    unregisterBarRenderer(key: string, renderer: BarRendererBase): void;
-    getRendererForBar(key: string, bar: Bar): BarRendererBase | null;
-    protected layoutAndRenderBottomScoreInfo(y: number): number;
-    protected alignScoreInfoGlyph(glyph: TextGlyph): void;
-    layoutAndRenderAnnotation(y: number): number;
-}

package/dist/types/alphatab/src/rendering/staves/BarLayoutingInfo.d.ts

@@ -1,44 +0,0 @@
-import type { Beat } from "./../../model/Beat";
-import { Spring } from "./Spring";
-import type { ICanvas } from "./../../platform/ICanvas";
-/**
- * This public class stores size information about a stave.
- * It is used by the layout engine to collect the sizes of score parts
- * to align the parts across multiple staves.
- * @internal
- */
-export declare class BarLayoutingInfo {
-    private static readonly _defaultMinDuration;
-    private static readonly _defaultMinDurationWidth;
-    private _timeSortedSprings;
-    private _minTime;
-    private _onTimePositionsForce;
-    private _onTimePositions;
-    private _incompleteGraceRodsWidth;
-    private _minDuration;
-    /**
-     * an internal version number that increments whenever a change was made.
-     */
-    version: number;
-    preBeatSize: number;
-    postBeatSize: number;
-    minStretchForce: number;
-    totalSpringConstant: number;
-    private _updateMinStretchForce;
-    getPreBeatSize(beat: Beat): number;
-    getPostBeatSize(beat: Beat): number;
-    incompleteGraceRods: Map<string, Spring[]>;
-    allGraceRods: Map<string, Spring[]>;
-    springs: Map<number, Spring>;
-    addSpring(start: number, duration: number, graceBeatWidth: number, preBeatWidth: number, postSpringSize: number): Spring;
-    addBeatSpring(beat: Beat, preBeatSize: number, postBeatSize: number): void;
-    finish(): void;
-    private _calculateSpringConstants;
-    height: number;
-    paint(_cx: number, _cy: number, _canvas: ICanvas): void;
-    private _calculateSpringConstant;
-    spaceToForce(space: number): number;
-    calculateVoiceWidth(force: number): number;
-    private _calculateWidth;
-    buildOnTimePositions(force: number): Map<number, number>;
-}

package/dist/types/alphatab/src/rendering/staves/MasterBarsRenderers.d.ts

@@ -1,18 +0,0 @@
-import type { MasterBar } from "./../../model/MasterBar";
-import type { BarRendererBase } from "./../BarRendererBase";
-import type { BarLayoutingInfo } from "./BarLayoutingInfo";
-/**
- * This container represents a single column of bar renderers independent from any staves.
- * This container can be used to reorganize renderers into a new staves.
- * @internal
- */
-export declare class MasterBarsRenderers {
-    width: number;
-    isLinkedToPrevious: boolean;
-    canWrap: boolean;
-    masterBar: MasterBar;
-    additionalMultiBarRestIndexes: number[] | null;
-    get lastMasterBarIndex(): number;
-    renderers: BarRendererBase[];
-    layoutingInfo: BarLayoutingInfo;
-}

package/dist/types/alphatab/src/rendering/staves/RenderStaff.d.ts

@@ -1,72 +0,0 @@
-import type { Bar } from "./../../model/Bar";
-import type { Staff } from "./../../model/Staff";
-import type { ICanvas } from "./../../platform/ICanvas";
-import type { BarRendererBase } from "./../BarRendererBase";
-import type { BarRendererFactory } from "./../BarRendererFactory";
-import type { BarLayoutingInfo } from "./BarLayoutingInfo";
-import type { StaffSystem } from "./StaffSystem";
-import type { StaffTrackGroup } from "./StaffTrackGroup";
-/**
- * A Staff represents a single line within a StaffSystem.
- * It stores BarRenderer instances created from a given factory.
- * @internal
- */
-export declare class RenderStaff {
-    private _factory;
-    private _sharedLayoutData;
-    staffTrackGroup: StaffTrackGroup;
-    system: StaffSystem;
-    barRenderers: BarRendererBase[];
-    x: number;
-    y: number;
-    height: number;
-    index: number;
-    staffIndex: number;
-    isFirstInSystem: boolean;
-    /**
-     * This is the index of the track being rendered. This is not the index of the track within the model,
-     * but the n-th track being rendered. It is the index of the {@link ScoreRenderer.tracks} array defining
-     * which tracks should be rendered.
-     * For single-track rendering this will always be zero.
-     */
-    trackIndex: number;
-    modelStaff: Staff;
-    get staffId(): string;
-    /**
-     * This is the visual offset from top where the
-     * Staff contents actually start. Used for grouping
-     * using a accolade
-     */
-    staveTop: number;
-    topSpacing: number;
-    bottomSpacing: number;
-    /**
-     * This is the visual offset from top where the
-     * Staff contents actually ends. Used for grouping
-     * using a accolade
-     */
-    staveBottom: number;
-    get contentTop(): number;
-    get contentBottom(): number;
-    constructor(trackIndex: number, staff: Staff, factory: BarRendererFactory);
-    getSharedLayoutData<T>(key: string, def: T): T;
-    setSharedLayoutData<T>(key: string, def: T): void;
-    get isInsideBracket(): boolean;
-    get isRelevantForBoundsLookup(): boolean;
-    registerStaffTop(offset: number): void;
-    registerStaffBottom(offset: number): void;
-    addBarRenderer(renderer: BarRendererBase): void;
-    addBar(bar: Bar, layoutingInfo: BarLayoutingInfo, additionalMultiBarsRestBars: Bar[] | null): void;
-    revertLastBar(): BarRendererBase;
-    scaleToWidth(width: number): void;
-    get topOverflow(): number;
-    get bottomOverflow(): number;
-    /**
-     * Performs an early calculation of the expected staff height for the size calculation in the
-     * accolade (e.g. for braces). This typically happens after the first bar renderers were created
-     * and we can do an early placement of the render staffs.
-     */
-    calculateHeightForAccolade(): void;
-    finalizeStaff(): void;
-    paint(cx: number, cy: number, canvas: ICanvas, startIndex: number, count: number): void;
-}

package/dist/types/alphatab/src/rendering/staves/Spring.d.ts

@@ -1,16 +0,0 @@
-/**
- * @internal
- */
-export declare class Spring {
-    timePosition: number;
-    longestDuration: number;
-    smallestDuration: number;
-    force: number;
-    springConstant: number;
-    get springWidth(): number;
-    preBeatWidth: number;
-    graceBeatWidth: number;
-    postSpringWidth: number;
-    get preSpringWidth(): number;
-    allDurations: Set<number>;
-}

package/dist/types/alphatab/src/rendering/staves/StaffSystem.d.ts

@@ -1,75 +0,0 @@
-import { type Track } from "./../../model/Track";
-import { type ICanvas } from "./../../platform/ICanvas";
-import type { ScoreLayout } from "./../layout/ScoreLayout";
-import { MasterBarsRenderers } from "./MasterBarsRenderers";
-import type { RenderStaff } from "./RenderStaff";
-import { StaffTrackGroup } from "./StaffTrackGroup";
-import type { EngravingSettings } from "./../../EngravingSettings";
-/**
- * @internal
- */
-export declare abstract class SystemBracket {
-    firstStaffInBracket: RenderStaff | null;
-    lastStaffInBracket: RenderStaff | null;
-    drawAsBrace: boolean;
-    braceScale: number;
-    width: number;
-    index: number;
-    abstract includesStaff(s: RenderStaff): boolean;
-    finalizeBracket(smuflMetrics: EngravingSettings): void;
-}
-/**
- * A StaffSystem consists of a list of different staves and groups
- * them using an accolade.
- * @internal
- */
-export declare class StaffSystem {
-    private _allStaves;
-    private _firstStaffInBrackets;
-    private _lastStaffInBrackets;
-    private _accoladeSpacingCalculated;
-    private _brackets;
-    private _hasSystemSeparator;
-    x: number;
-    y: number;
-    index: number;
-    /**
-     * The width of the whole accolade inclusive text and bar.
-     */
-    accoladeWidth: number;
-    /**
-     * Indicates whether this line is full or not. If the line is full the
-     * bars can be aligned to the maximum width. If the line is not full
-     * the bars will not get stretched.
-     */
-    isFull: boolean;
-    /**
-     * The width that the content bars actually need
-     */
-    width: number;
-    computedWidth: number;
-    totalBarDisplayScale: number;
-    isLast: boolean;
-    masterBarsRenderers: MasterBarsRenderers[];
-    staves: StaffTrackGroup[];
-    layout: ScoreLayout;
-    topPadding: number;
-    bottomPadding: number;
-    constructor(layout: ScoreLayout);
-    get firstBarIndex(): number;
-    get lastBarIndex(): number;
-    addMasterBarRenderers(tracks: Track[], renderers: MasterBarsRenderers): MasterBarsRenderers | null;
-    addBars(tracks: Track[], barIndex: number, additionalMultiBarRestIndexes: number[] | null): MasterBarsRenderers;
-    revertLastBar(): MasterBarsRenderers | null;
-    private _updateWidthFromLastBar;
-    private _calculateAccoladeSpacing;
-    private _getStaffTrackGroup;
-    addStaff(track: Track, staff: RenderStaff): void;
-    get height(): number;
-    scaleToWidth(width: number): void;
-    paint(cx: number, cy: number, canvas: ICanvas): void;
-    paintPartial(cx: number, cy: number, canvas: ICanvas, startIndex: number, count: number): void;
-    finalizeSystem(): void;
-    buildBoundingsLookup(cx: number, cy: number): void;
-    getBarX(index: number): number;
-}

package/dist/types/alphatab/src/rendering/staves/StaffTrackGroup.d.ts

@@ -1,20 +0,0 @@
-import type { Track } from "./../../model/Track";
-import type { RenderStaff } from "./RenderStaff";
-import type { StaffSystem, SystemBracket } from "./StaffSystem";
-/**
- * Represents the group of rendered staves belonging to an individual track.
- * This includes staves like effects, notation representations (numbered, tabs,..) and multiple
- * staffs (grand staff).
- * @internal
- */
-export declare class StaffTrackGroup {
-    track: Track;
-    staffSystem: StaffSystem;
-    staves: RenderStaff[];
-    stavesRelevantForBoundsLookup: RenderStaff[];
-    firstStaffInBracket: RenderStaff | null;
-    lastStaffInBracket: RenderStaff | null;
-    bracket: SystemBracket | null;
-    constructor(staffSystem: StaffSystem, track: Track);
-    addStaff(staff: RenderStaff): void;
-}

package/dist/types/alphatab/src/rendering/utils/AccidentalHelper.d.ts

@@ -1,89 +0,0 @@
-import { AccidentalType } from "./../../model/AccidentalType";
-import type { Bar } from "./../../model/Bar";
-import type { Beat } from "./../../model/Beat";
-import type { Note } from "./../../model/Note";
-import type { LineBarRenderer } from "./../LineBarRenderer";
-import type { Clef } from "./../../model/Clef";
-import type { KeySignature } from "./../../model/KeySignature";
-/**
- * This small utilty public class allows the assignment of accidentals within a
- * desired scope.
- * @internal
- */
-export declare class AccidentalHelper {
-    private _bar;
-    private _barRenderer;
-    /**
-     * We always have 7 steps per octave.
-     * (by a step the offsets inbetween score lines is meant,
-     *      0 steps is on the first line (counting from top)
-     *      1 steps is on the space inbetween the first and the second line
-     */
-    private static readonly _stepsPerOctave;
-    /**
-     * Those are the amount of steps for the different clefs in case of a note value 0
-     * [Neutral, C3, C4, F4, G2]
-     */
-    private static _octaveSteps;
-    /**
-     * The step offsets of the notes within an octave in case of for sharp keysignatures
-     */
-    static readonly sharpNoteSteps: number[];
-    /**
-     * The step offsets of the notes within an octave in case of for flat keysignatures
-     */
-    static readonly flatNoteSteps: number[];
-    private _registeredAccidentals;
-    private _appliedScoreLines;
-    private _appliedScoreLinesByValue;
-    private _notesByValue;
-    private _beatLines;
-    /**
-     * The beat on which the highest note of this helper was added.
-     * Used together with beaming helper to calculate overflow.
-     */
-    maxLineBeat: Beat | null;
-    /**
-     * The beat on which the lowest note of this helper was added.
-     * Used together with beaming helper to calculate overflow.
-     */
-    minLineBeat: Beat | null;
-    /**
-     * The line of the highest note added to this helper.
-     */
-    maxLine: number;
-    /**
-     * The line of the lowest note added to this helper.
-     */
-    minLine: number;
-    constructor(barRenderer: LineBarRenderer);
-    static getPercussionLine(bar: Bar, noteValue: number): number;
-    static getNoteValue(note: Note): number;
-    /**
-     * Calculates the accidental for the given note and assignes the value to it.
-     * The new accidental type is also registered within the current scope
-     * @param note
-     * @returns
-     */
-    applyAccidental(note: Note): AccidentalType;
-    /**
-     * Calculates the accidental for the given note value and assignes the value to it.
-     * The new accidental type is also registered within the current scope
-     * @param relatedBeat
-     * @param noteValue
-     * @param quarterBend
-     * @param isHelperNote true if the note registered via this call, is a small helper note (e.g. for bends) or false if it is a main note head (e.g. for harmonics)
-     * @returns
-     */
-    applyAccidentalForValue(relatedBeat: Beat, noteValue: number, quarterBend: boolean, isHelperNote: boolean): AccidentalType;
-    static computeLineWithoutAccidentals(bar: Bar, note: Note): number;
-    private _getAccidental;
-    private _registerLine;
-    getMaxLine(b: Beat): number;
-    getMaxLineNote(b: Beat): Note | null;
-    getMinLine(b: Beat): number;
-    getMinLineNote(b: Beat): Note | null;
-    static calculateNoteSteps(keySignature: KeySignature, clef: Clef, noteValue: number): number;
-    getNoteLine(n: Note): number;
-    getNoteLineForValue(rawValue: number, searchForNote?: boolean): number;
-}

package/dist/types/alphatab/src/rendering/utils/BarBounds.d.ts

@@ -1,45 +0,0 @@
-import type { Bar } from "./../../model/Bar";
-import type { BeatBounds } from "./BeatBounds";
-import type { Bounds } from "./Bounds";
-import type { MasterBarBounds } from "./MasterBarBounds";
-/**
- * Represents the boundaries of a single bar.
- * @public
- */
-export declare class BarBounds {
-    /**
-     * Gets or sets the reference to the related {@link MasterBarBounds}
-     */
-    masterBarBounds: MasterBarBounds;
-    /**
-     * Gets or sets the bounds covering all visually visible elements spanning this bar.
-     */
-    visualBounds: Bounds;
-    /**
-     * Gets or sets the actual bounds of the elements in this bar including whitespace areas.
-     */
-    realBounds: Bounds;
-    /**
-     * Gets or sets the bar related to this boundaries.
-     */
-    bar: Bar;
-    /**
-     * Gets or sets a list of the beats contained in this lookup.
-     */
-    beats: BeatBounds[];
-    /**
-     * Adds a new beat to this lookup.
-     * @param bounds The beat bounds to add.
-     */
-    addBeat(bounds: BeatBounds): void;
-    /**
-     * Tries to find the beat at the given X-position.
-     * @param x The X-position of the beat to find.
-     * @returns The beat at the given X-position or null if none was found.
-     */
-    findBeatAtPos(x: number): BeatBounds | null;
-    /**
-     * Finishes the lookup object and optimizes itself for fast access.
-     */
-    finish(scale?: number): void;
-}

package/dist/types/alphatab/src/rendering/utils/BarCollisionHelper.d.ts

@@ -1,31 +0,0 @@
-import type { Beat } from "./../../model/Beat";
-/**
- * @internal
- */
-export declare class ReservedLayoutAreaSlot {
-    topY: number;
-    bottomY: number;
-    constructor(topY: number, bottomY: number);
-}
-/**
- * @internal
- */
-export declare class ReservedLayoutArea {
-    beat: Beat;
-    topY: number;
-    bottomY: number;
-    slots: ReservedLayoutAreaSlot[];
-    constructor(beat: Beat);
-    addSlot(topY: number, bottomY: number): void;
-}
-/**
- * @internal
- */
-export declare class BarCollisionHelper {
-    reservedLayoutAreasByDisplayTime: Map<number, ReservedLayoutArea>;
-    restDurationsByDisplayTime: Map<number, Map<number, number>>;
-    getBeatMinMaxY(): number[];
-    reserveBeatSlot(beat: Beat, topY: number, bottomY: number): void;
-    registerRest(beat: Beat): void;
-    applyRestCollisionOffset(beat: Beat, currentY: number, linesToPixel: number): number;
-}

package/dist/types/alphatab/src/rendering/utils/BarHelpers.d.ts

@@ -1,18 +0,0 @@
-import type { Beat } from "./../../model/Beat";
-import { BeamingHelper } from "./BeamingHelper";
-import type { BarRendererBase } from "./../BarRendererBase";
-import { BarCollisionHelper } from "./BarCollisionHelper";
-import type { BeamDirection } from "./BeamDirection";
-/**
- * @internal
- */
-export declare class BarHelpers {
-    private _renderer;
-    beamHelpers: BeamingHelper[][];
-    beamHelperLookup: Map<number, BeamingHelper>[];
-    collisionHelper: BarCollisionHelper;
-    preferredBeamDirection: BeamDirection | null;
-    constructor(renderer: BarRendererBase);
-    initialize(): void;
-    getBeamingHelperForBeat(beat: Beat): BeamingHelper;
-}

package/dist/types/alphatab/src/rendering/utils/BeamDirection.d.ts

@@ -1,7 +0,0 @@
-/**
- * @public
- */
-export declare enum BeamDirection {
-    Up = 0,
-    Down = 1
-}

package/dist/types/alphatab/src/rendering/utils/BeamingHelper.d.ts

@@ -1,92 +0,0 @@
-import { type Beat } from "./../../model/Beat";
-import { Duration } from "./../../model/Duration";
-import { GraceType } from "./../../model/GraceType";
-import type { Note } from "./../../model/Note";
-import type { Staff } from "./../../model/Staff";
-import type { Voice } from "./../../model/Voice";
-import { BeamDirection } from "./BeamDirection";
-import { type BarRendererBase } from "./../BarRendererBase";
-/**
- * @internal
- */
-export declare class BeamingHelperDrawInfo {
-    startBeat: Beat | null;
-    startX: number;
-    startY: number;
-    endBeat: Beat | null;
-    endX: number;
-    endY: number;
-    /**
-     * calculates the Y-position given a X-pos using the current start end point
-     * @param x
-     */
-    calcY(x: number): number;
-}
-/**
- * This public class helps drawing beams and bars for notes.
- * @internal
- */
-export declare class BeamingHelper {
-    private _staff;
-    private _beatLineXPositions;
-    private _renderer;
-    private _firstNonRestBeat;
-    private _lastNonRestBeat;
-    voice: Voice | null;
-    beats: Beat[];
-    shortestDuration: Duration;
-    tremoloDuration?: Duration;
-    /**
-     * an indicator whether any beat has a tuplet on it.
-     */
-    hasTuplet: boolean;
-    slashBeats: Beat[];
-    lowestNoteInHelper: Note | null;
-    private _lowestNoteCompareValueInHelper;
-    highestNoteInHelper: Note | null;
-    private _highestNoteCompareValueInHelper;
-    invertBeamDirection: boolean;
-    preferredBeamDirection: BeamDirection | null;
-    graceType: GraceType;
-    minRestLine: number | null;
-    beatOfMinRestLine: Beat | null;
-    maxRestLine: number | null;
-    beatOfMaxRestLine: Beat | null;
-    get isRestBeamHelper(): boolean;
-    hasLine(forceFlagOnSingleBeat: boolean, beat?: Beat): boolean;
-    private _beatHasLine;
-    hasFlag(forceFlagOnSingleBeat: boolean, beat?: Beat): boolean;
-    private _beatHasFlag;
-    constructor(staff: Staff, renderer: BarRendererBase);
-    getBeatLineX(beat: Beat, direction?: BeamDirection): number;
-    hasBeatLineX(beat: Beat): boolean;
-    registerBeatLineX(staffId: string, beat: Beat, up: number, down: number): void;
-    private _getOrCreateBeatPositions;
-    direction: BeamDirection;
-    finish(): void;
-    private _calculateDirection;
-    static computeLineHeightsForRest(duration: Duration): number[];
-    /**
-     * Registers a rest beat within the accidental helper so the rest
-     * symbol is considered properly during beaming.
-     * @param beat The rest beat.
-     * @param line The line on which the rest symbol is placed
-     */
-    applyRest(beat: Beat, line: number): void;
-    private _invert;
-    checkBeat(beat: Beat): boolean;
-    private _checkNote;
-    private static _canJoin;
-    private static _canJoinDuration;
-    static isFullBarJoin(a: Beat, b: Beat, barIndex: number): boolean;
-    get beatOfLowestNote(): Beat;
-    get beatOfHighestNote(): Beat;
-    /**
-     * Returns whether the the position of the given beat, was registered by the staff of the given ID
-     * @param staffId
-     * @param beat
-     * @returns
-     */
-    isPositionFrom(staffId: string, beat: Beat): boolean;
-    drawingInfos: Map<BeamDirection, BeamingHelperDrawInfo>;
-}

package/dist/types/alphatab/src/rendering/utils/BeatBounds.d.ts

@@ -1,52 +0,0 @@
-import type { Beat } from "./../../model/Beat";
-import type { Note } from "./../../model/Note";
-import type { BarBounds } from "./BarBounds";
-import type { Bounds } from "./Bounds";
-import type { NoteBounds } from "./NoteBounds";
-/**
- * Represents the bounds of a single beat.
- * @public
- */
-export declare class BeatBounds {
-    /**
-     * Gets or sets the reference to the parent {@link BarBounds}.
-     */
-    barBounds: BarBounds;
-    /**
-     * Gets or sets the bounds covering all visually visible elements spanning this beat.
-     */
-    visualBounds: Bounds;
-    /**
-     * Gets or sets x-position where the timely center of the notes for this beat is.
-     * This is where the cursor should be at the time when this beat is played.
-     */
-    onNotesX: number;
-    /**
-     * Gets or sets the actual bounds of the elements in this beat including whitespace areas.
-     */
-    realBounds: Bounds;
-    /**
-     * Gets or sets the beat related to this bounds.
-     */
-    beat: Beat;
-    /**
-     * Gets or sets the individual note positions of this beat (if {@link CoreSettings.includeNoteBounds} was set to true).
-     */
-    notes: NoteBounds[] | null;
-    /**
-     * Adds a new note to this bounds.
-     * @param bounds The note bounds to add.
-     */
-    addNote(bounds: NoteBounds): void;
-    /**
-     * Tries to find a note at the given position.
-     * @param x The X-position of the note to find.
-     * @param y The Y-position of the note to find.
-     * @returns The note at the given position or null if no note was found, or the note lookup was not enabled before rendering.
-     */
-    findNoteAtPos(x: number, y: number): Note | null;
-    /**
-     * Finishes the lookup object and optimizes itself for fast access.
-     */
-    finish(scale?: number): void;
-}