@tspro/web-music-score 2.0.0 → 3.0.0

package/dist/interface-DXyXwLBB.d.ts

@@ -0,0 +1,1768 @@
+import { N as Note, A as Accidental } from './note-B5ZtlHc8.js';
+import { R as RhythmProps, N as NoteLength, c as Tempo, K as KeySignature, a as TimeSignature, T as TimeSignatureString } from './tempo-DoJd-UYT.js';
+import { Vec2 } from '@tspro/ts-utils-lib';
+
+/**
+ * @public
+ *
+ * DivRect class, left, top, right, bottom rectangle divided into four sections by centerX, centerY.
+ */
+declare class DivRect {
+    left: number;
+    centerX: number;
+    right: number;
+    top: number;
+    centerY: number;
+    bottom: number;
+    /**
+     * Create rectangle with all zero values.
+     */
+    constructor();
+    /**
+     * Create rectangle with left, right, top, bottom.
+     * Properties centerX and centerY will be centered in the middle.
+     *
+     * @param left -
+     * @param right -
+     * @param top -
+     * @param bottom -
+     */
+    constructor(left: number, right: number, top: number, bottom: number);
+    /**
+     * Create rectangle with full arguments.
+     *
+     * @param left -
+     * @param centerX -
+     * @param right -
+     * @param top -
+     * @param centerY -
+     * @param bottom -
+     */
+    constructor(left: number, centerX: number, right: number, top: number, centerY: number, bottom: number);
+    /**
+     * Create rect from basic left, top, width and height arguments.
+     *
+     * @param left -
+     * @param top -
+     * @param width -
+     * @param height -
+     * @returns
+     */
+    static create(left: number, top: number, width: number, height: number): DivRect;
+    /**
+     * Create rect from centerX, centerY, width, height arguments.
+     *
+     * @param centerX - Center x-coordinate.
+     * @param centerY - Center y-coordinate.
+     * @param width -
+     * @param height -
+     * @returns
+     */
+    static createCentered(centerX: number, centerY: number, width: number, height: number): DivRect;
+    /**
+     * Create rect from sections.
+     *
+     * @param leftw - Left section width.
+     * @param rightw - Right section width.
+     * @param toph - Top section height.
+     * @param bottomh - Bottomsection height.
+     * @returns
+     */
+    static createSections(leftw: number, rightw: number, toph: number, bottomh: number): DivRect;
+    /**
+     * Width.
+     */
+    get width(): number;
+    /**
+     * Height.
+     */
+    get height(): number;
+    /**
+     * Left section width.
+     */
+    get leftw(): number;
+    /**
+     * Right section width.
+     */
+    get rightw(): number;
+    /**
+     * Top section height.
+     */
+    get toph(): number;
+    /**
+     * Bottom section height.
+     */
+    get bottomh(): number;
+    /**
+     * Does this Rect contain given (x, y)-point?
+     *
+     * @param x -
+     * @param y -
+     * @returns
+     */
+    contains(x: number, y: number): boolean;
+    /**
+     * Do a and b rects overlap?
+     *
+     * @param a -
+     * @param b -
+     * @returns
+     */
+    static overlap(a: DivRect, b: DivRect): boolean;
+    /**
+     * Do horizontal measures of a and b rects overlap?
+     *
+     * @param a -
+     * @param b -
+     * @returns
+     */
+    static overlapX(a: DivRect, b: DivRect): boolean;
+    /**
+     * Check if this Rect equals with given Rect.
+     * @param b -
+     * @returns
+     */
+    static equals(a: DivRect | null | undefined, b: DivRect | null | undefined): boolean;
+    /**
+     * Check if frame (ignoring centerX/Y) of this Rect equals with given Rect, ignoring centerX and centerY.
+     *
+     * @param b -
+     * @returns
+     */
+    static equalsFrame(a: DivRect | null | undefined, b: DivRect | null | undefined): boolean;
+    /**
+     * Created duplicate of this Rect.
+     *
+     * @returns
+     */
+    copy(): DivRect;
+    /**
+     * Move this rect by (dx, dy). Modifies this Rect.
+     *
+     * @param dx -
+     * @param dy -
+     * @returns
+     */
+    offsetInPlace(dx: number, dy: number): DivRect;
+    /**
+     * Move this rect by (dx, dy). Immutable, returns modified copy.
+     *
+     * @param dx -
+     * @param dy -
+     * @returns
+     */
+    offsetCopy(dx: number, dy: number): DivRect;
+    /**
+     * Expand this Rect by given Rect. Modifies this Rect.
+     *
+     * @param rect -
+     * @returns
+     */
+    expandInPlace(rect: DivRect): DivRect;
+    /**
+     * Expand this Rect by given Rect. Immutable, returns modified copy.
+     *
+     * @param rect -
+     * @returns
+     */
+    expandCopy(rect: DivRect): DivRect;
+    /**
+     * Clip this Rect by given Rect. Mmodifies this Rect.
+     *
+     * @param clipRect -
+     * @returns
+     */
+    clipInPlace(clipRect: DivRect): DivRect;
+    /**
+     * Clip this Rect by given Rect. Immutable, return modified copy.
+     *
+     * @param clipRect -
+     * @returns
+     */
+    clipCopy(clipRect: DivRect): DivRect;
+    /**
+     * Scale Rect. Anchor pos is (centerX, centerY). Modifies this Rect.
+     *
+     * @param scaleX -
+     * @param scaleY -
+     * @returns Copy of scaled Rect.
+     */
+    scaleInPlace(scaleX: number, scaleY?: number): DivRect;
+    /**
+     * Scale Rect. Anchor pos is (centerX, centerY). Immutable, returns modified copy.
+     *
+     * @param scaleX -
+     * @param scaleY -
+     * @returns Copy of scaled Rect.
+     */
+    scaleCopy(scaleX: number, scaleY?: number): DivRect;
+    getRect(): DivRect;
+}
+
+/** @public */
+declare enum StaffPreset {
+    /** Treble staff has treble (G-) clef. */
+    Treble = 1,
+    /** Bass staff has bass (F-) clef. */
+    Bass = 2,
+    /** Grand staff has both treble and bass clefs. */
+    Grand = 3,
+    /** GuitarTreble has treble clef but is one octave lower. */
+    GuitarTreble = 4,
+    GuitarTab = 8,
+    GuitarCombined = 12
+}
+/** @public */
+declare enum Clef {
+    G = "G",
+    F = "F"
+}
+/** @public */
+type StaffConfig = {
+    type: "staff";
+    clef: Clef;
+    isOctaveDown?: boolean;
+    minNote?: string;
+    maxNote?: string;
+    voiceIds?: number[];
+    isGrand?: boolean;
+};
+/** @public */
+type TabConfig = {
+    type: "tab";
+    tuning?: string | string[];
+    voiceIds?: number[];
+};
+/** @public */
+type ScoreConfiguration = StaffConfig | TabConfig | (StaffConfig | TabConfig)[];
+/** @public */
+type VoiceId = 0 | 1 | 2 | 3;
+/** @public */
+declare function getVoiceIds(): ReadonlyArray<VoiceId>;
+/** @public */
+type StringNumber = 1 | 2 | 3 | 4 | 5 | 6;
+/** @public */
+declare function getStringNumbers(): ReadonlyArray<StringNumber>;
+/** @public */
+declare enum Stem {
+    Auto = 0,
+    Up = 1,
+    Down = 2
+}
+/** @public */
+declare enum Arpeggio {
+    Up = 0,
+    Down = 1
+}
+/** @public */
+declare enum TieType {
+    Stub = -1,
+    ToMeasureEnd = -2
+}
+/** @public */
+declare enum NoteAnchor {
+    Auto = 0,
+    Above = 1,
+    Center = 2,
+    Below = 3,
+    StemTip = 4
+}
+/** @public */
+declare enum Connective {
+    Tie = 0,
+    Slur = 1,
+    Slide = 2
+}
+/** @public */
+type ConnectiveSpan = number | TieType;
+/** @public */
+type NoteOptions = {
+    dotted?: boolean;
+    stem?: Stem;
+    color?: string;
+    arpeggio?: Arpeggio | boolean;
+    staccato?: boolean;
+    diamond?: boolean;
+    triplet?: boolean;
+    string?: StringNumber | StringNumber[];
+};
+/** @public */
+type RestOptions = {
+    dotted?: boolean;
+    staffPos?: Note | string | number;
+    color?: string;
+    hide?: boolean;
+    triplet?: boolean;
+};
+/** @public */
+declare enum PlayState {
+    Playing = 0,
+    Paused = 1,
+    Stopped = 2
+}
+/** @public */
+type PlayStateChangeListener = (playState: PlayState) => void;
+/** @public */
+declare enum Fermata {
+    AtNote = 0,
+    AtMeasureEnd = 1
+}
+/** @public */
+declare enum Navigation {
+    /** Repeat back to beginning and play to the "Fine" marking. */
+    DC_al_Fine = 0,
+    /** Repeat back to beginning and play to the "to Coda 𝄌", then jump to the "𝄌 Coda". */
+    DC_al_Coda = 1,
+    /** Repeat back to Segno sign (𝄋) and play to the "Fine" marking. */
+    DS_al_Fine = 2,
+    /** Repeat back to Segno sign (𝄋) and play to the "to Coda 𝄌", then jump to the "𝄌 Coda". */
+    DS_al_Coda = 3,
+    /** "𝄌 Coda" section. */
+    Coda = 4,
+    /** From "toCoda 𝄌" jump to the "𝄌 Coda" section. */
+    toCoda = 5,
+    /** Jump here from D.S. al Fine or D.S. al Coda. */
+    Segno = 6,
+    /** Stop playing after D.C. al Fine or D.S. al Fine. */
+    Fine = 7,
+    /** Start of repeat section. */
+    StartRepeat = 8,
+    /** End of repeat section. Jump to start of repeat section. */
+    EndRepeat = 9,
+    /** Jump to ending with correct passage number. */
+    Ending = 10
+}
+/** @public */
+declare enum Annotation {
+    /** "ppp", "pp", "p", "mp", "m", "mf", "f", "ff", "fff", "cresc.", "decresc.", "dim." */
+    Dynamics = 0,
+    /** "accel.", "rit.", "a tempo" */
+    Tempo = 1
+}
+/** @public */
+declare enum Label {
+    /** "C", "C#", "Db", "D", etc. */
+    Note = 0,
+    /** "C", "Am", "G7", etc. */
+    Chord = 1
+}
+
+declare class AccidentalState {
+    readonly measure: ObjMeasure;
+    private readonly accidentalByDiatonicId;
+    constructor(measure: ObjMeasure);
+    getAccidentalFromKeySignature(diatonicId: number): Accidental | undefined;
+    setAccidental(note: Note): void;
+    needAccidental(note: Note): boolean;
+}
+
+declare class ConnectiveProps {
+    readonly connective: Connective;
+    readonly span: ConnectiveSpan;
+    noteAnchor: NoteAnchor;
+    noteGroups: ObjNoteGroup[];
+    arcDir: "up" | "down";
+    constructor(connective: Connective, span: ConnectiveSpan, noteAnchor: NoteAnchor, startNoteGroup: ObjNoteGroup);
+    getStartNoteGroup(): ObjNoteGroup;
+    startsWith(noteGroup: ObjNoteGroup): boolean;
+    /**
+     *
+     * @param noteGroup -
+     * @returns true if noteGroup was added, false if not.
+     */
+    addNoteGroup(noteGroup: ObjNoteGroup): boolean;
+    private computeParams;
+    removeConnectives(): void;
+    createConnectives(): void;
+    private createObjConnectiveWithTieType;
+    private createObjConnective;
+}
+
+declare class ObjAccidental extends MusicObject {
+    readonly diatonicId: number;
+    readonly accidental: Accidental;
+    readonly color: string;
+    readonly mi: MAccidental;
+    constructor(parent: MusicObject, diatonicId: number, accidental: Accidental, color?: string);
+    getMusicInterface(): MAccidental;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+type BoxType = "square" | "rectangle" | "circle" | "ellipse";
+type TextProps = string | {
+    text: string;
+    scale?: number;
+    color?: string;
+    bold?: boolean;
+    italic?: boolean;
+    boxed?: BoxType;
+    padding?: number;
+    bgcolor?: string;
+};
+declare class ObjText extends MusicObject {
+    private anchorX;
+    private anchorY;
+    private readonly text;
+    private readonly scale;
+    private readonly color;
+    private readonly bold;
+    private readonly italic;
+    private readonly boxed;
+    private readonly padding;
+    private readonly bgcolor?;
+    private font;
+    private textLines;
+    private lineWidths;
+    private lineHeight;
+    readonly mi: MText;
+    constructor(parent: MusicObject, text: TextProps, anchorX: number, anchorY: number);
+    getMusicInterface(): MText;
+    getText(): string;
+    updateAnchorX(anchorX: number): void;
+    updateAnchorY(anchorY: number): void;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+type NotationLineObject = {
+    getRect: () => DivRect;
+    offset?: (dx: number, dy: number) => void;
+    offsetInPlace?: (dx: number, dy: number) => void;
+};
+declare class ObjStaff extends MusicObject {
+    readonly row: ObjScoreRow;
+    readonly staffConfig: StaffConfig;
+    readonly clefImageAsset: ImageAsset;
+    readonly clefLineDiatonicId: number;
+    readonly topLineDiatonicId: number;
+    readonly middleLineDiatonicId: number;
+    readonly bottomLineDiatonicId: number;
+    readonly minDiatonicId?: number;
+    readonly maxDiatonicId?: number;
+    private joinedGrandStaff?;
+    private topLineY;
+    private bottomLineY;
+    private readonly objects;
+    readonly mi: MStaff;
+    constructor(row: ObjScoreRow, staffConfig: StaffConfig);
+    getMusicInterface(): MStaff;
+    get isOctaveDown(): boolean;
+    getTopLineY(): number;
+    getMiddleLineY(): number;
+    getBottomLineY(): number;
+    joinGrandStaff(staff: ObjStaff): void;
+    getLineSpacing(): number;
+    getDiatonicSpacing(): number;
+    containsDiatonicId(diatonicId: number): boolean;
+    getDiatonicIdY(diatonicId: number): number;
+    getActualStaff(diatonicId: number): ObjStaff | undefined;
+    getDiatonicIdAt(y: number): number | undefined;
+    isLine(diatonicId: number): boolean;
+    isSpace(diatonicId: number): boolean;
+    containsVoiceId(voiceId: number): boolean;
+    isGrand(): boolean;
+    calcTop(): number;
+    calcBottom(): number;
+    addObject(o: NotationLineObject): void;
+    removeObjects(): void;
+    pick(x: number, y: number): MusicObject[];
+    layoutHeight(renderer: Renderer): void;
+    layoutWidth(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+declare class ObjTab extends MusicObject {
+    readonly row: ObjScoreRow;
+    readonly tabConfig: TabConfig;
+    private top;
+    private bottom;
+    private readonly objects;
+    private readonly tuningName?;
+    private readonly tuningStrings;
+    readonly mi: MTab;
+    constructor(row: ObjScoreRow, tabConfig: TabConfig);
+    getMusicInterface(): MTab;
+    getTuningName(): string | undefined;
+    getTuningStrings(): ReadonlyArray<Note>;
+    /** Return Y coordinate of string. */
+    getStringY(stringId: number): number;
+    getTopStringY(): number;
+    getBottomStringY(): number;
+    getTop(): number;
+    getBottom(): number;
+    containsVoiceId(voiceId: number): boolean;
+    calcTop(): number;
+    calcBottom(): number;
+    addObject(o: NotationLineObject): void;
+    removeObjects(): void;
+    pick(x: number, y: number): MusicObject[];
+    layoutHeight(renderer: Renderer): void;
+    layoutWidth(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjStaffNoteGroup extends MusicObject {
+    readonly staff: ObjStaff;
+    readonly noteGroup: ObjNoteGroup;
+    noteHeadRects: DivRect[];
+    dotRects: DivRect[];
+    accidentals: ObjAccidental[];
+    stemTip?: DivRect;
+    stemBase?: DivRect;
+    flagRects: DivRect[];
+    private prevTopNoteY;
+    private prevBottomNoteY;
+    readonly mi: MStaffNoteGroup;
+    constructor(staff: ObjStaff, noteGroup: ObjNoteGroup);
+    getMusicInterface(): MusicInterface;
+    pick(x: number, y: number): MusicObject[];
+    updateRect(): void;
+    getRect(): DivRect;
+    offset(dx: number, dy: number): void;
+}
+declare class ObjTabNoteGroup extends MusicObject {
+    readonly tab: ObjTab;
+    readonly noteGroup: ObjNoteGroup;
+    fretNumbers: ObjText[];
+    readonly mi: MTabNoteGroup;
+    constructor(tab: ObjTab, noteGroup: ObjNoteGroup);
+    getMusicInterface(): MusicInterface;
+    pick(x: number, y: number): MusicObject[];
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+}
+declare class ObjNoteGroup extends MusicObject {
+    readonly col: ObjRhythmColumn;
+    readonly voiceId: number;
+    readonly notes: ReadonlyArray<Note>;
+    readonly minDiatonicId: number;
+    readonly maxDiatonicId: number;
+    readonly ownDiatonicId: number;
+    readonly ownStemDir: Stem.Up | Stem.Down;
+    readonly ownString: StringNumber[];
+    readonly color: string;
+    readonly staccato: boolean;
+    readonly diamond: boolean;
+    readonly arpeggio: Arpeggio | undefined;
+    readonly rhythmProps: RhythmProps;
+    private startConnnectives;
+    private runningConnectives;
+    private leftBeamCount;
+    private rightBeamCount;
+    private beamGroup?;
+    private readonly staffObjects;
+    private readonly tabObjects;
+    readonly mi: MNoteGroup;
+    constructor(col: ObjRhythmColumn, voiceId: number, notes: ReadonlyArray<Note>, noteLength: NoteLength, options?: NoteOptions);
+    getMusicInterface(): MNoteGroup;
+    get doc(): ObjDocument;
+    get measure(): ObjMeasure;
+    get row(): ObjScoreRow;
+    get stemDir(): Stem.Up | Stem.Down;
+    get triplet(): boolean;
+    enableConnective(line: ObjStaff | ObjTab): boolean;
+    startConnective(connectiveProps: ConnectiveProps): void;
+    pick(x: number, y: number): MusicObject[];
+    getTopNote(): Note;
+    getBottomNote(): Note;
+    getConnectiveAnchorPoint(connectiveProps: ConnectiveProps, line: ObjStaff | ObjTab, noteIndex: number, noteAnchor: NoteAnchor, side: "left" | "right"): {
+        x: number;
+        y: number;
+    };
+    getFretNumberString(noteIndex: number): number | undefined;
+    getFretNumber(tabObj: ObjTabNoteGroup, noteIndex: number): number | undefined;
+    private getNextNoteGroup;
+    collectConnectiveProps(): void;
+    removeConnectiveProps(): void;
+    getPlaySlur(): "first" | "slurred" | undefined;
+    getBeamGroup(): ObjBeamGroup | undefined;
+    setBeamGroup(beam: ObjBeamGroup): void;
+    resetBeamGroup(): void;
+    getBeamCoords(): ({
+        staff: ObjStaff;
+        x: number;
+        y: number;
+        stemHeight: number;
+    } | undefined)[];
+    getStemHeight(renderer: Renderer): number;
+    hasBeamCount(): boolean;
+    getLeftBeamCount(): number;
+    getRightBeamCount(): number;
+    isEmpty(): boolean;
+    visibleInStaff(staff: ObjStaff): boolean;
+    getPlayTicks(note: Note): number;
+    updateAccidentalState(accState: AccidentalState): void;
+    layout(renderer: Renderer, accState: AccidentalState): void;
+    updateRect(): void;
+    setStemTipY(staff: ObjStaff, stemTipY: number): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+    static setBeamCounts(groupNotes: (ObjNoteGroup | undefined)[]): void;
+    static setTripletBeamCounts(triplet: ObjBeamGroup): void;
+    getDotVerticalDisplacement(staff: ObjStaff, diatonicId: number, stemDir: Stem): 1 | 0 | -1;
+    static hasSameNotes(ng1: ObjNoteGroup, ng2: ObjNoteGroup): boolean;
+}
+
+declare enum BeamGroupType {
+    RegularBeam = 0,
+    TripletBeam = 1,
+    TripletGroup = 2
+}
+declare class BeamPoint {
+    staff: ObjStaff;
+    beamGroup: ObjBeamGroup;
+    symbol: RhythmSymbol;
+    x: number;
+    y: number;
+    topBeamsHeight: number;
+    bottomBeamsHeight: number;
+    constructor(staff: ObjStaff, beamGroup: ObjBeamGroup, symbol: RhythmSymbol, x: number, y: number);
+    offset(dx: number, dy: number): void;
+    getRect(): DivRect;
+}
+declare class ObjStaffBeamGroup extends MusicObject {
+    readonly staff: ObjStaff;
+    readonly beamGroup: ObjBeamGroup;
+    tripletNumber?: ObjText;
+    tripletNumberOffsetY: number;
+    points: BeamPoint[];
+    readonly mi: MStaffBeamGroup;
+    constructor(staff: ObjStaff, beamGroup: ObjBeamGroup);
+    getMusicInterface(): MusicInterface;
+    pick(x: number, y: number): MusicObject[];
+    offset(dx: number, dy: number): void;
+    updateRect(): void;
+}
+declare class ObjBeamGroup extends MusicObject {
+    private readonly symbols;
+    readonly mi: MBeamGroup;
+    private readonly type;
+    private readonly staffObjects;
+    private constructor();
+    static createBeam(noteGroups: ObjNoteGroup[]): void;
+    static createTriplet(symbols: RhythmSymbol[]): boolean;
+    getMusicInterface(): MBeamGroup;
+    detach(): void;
+    isEmpty(): boolean;
+    pick(x: number, y: number): MusicObject[];
+    getType(): BeamGroupType;
+    isTriplet(): boolean;
+    getSymbols(): ReadonlyArray<RhythmSymbol>;
+    getFirstSymbol(): RhythmSymbol | undefined;
+    getLastSymbol(): RhythmSymbol | undefined;
+    get stemDir(): Stem.Up | Stem.Down;
+    layout(renderer: Renderer): void;
+    updateRect(): void;
+    updateStemTips(): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjStaffRest extends MusicObject {
+    readonly staff: ObjStaff;
+    readonly rest: ObjRest;
+    restRect: DivRect;
+    dotRect?: DivRect;
+    readonly mi: MStaffRest;
+    constructor(staff: ObjStaff, rest: ObjRest);
+    getMusicInterface(): MusicInterface;
+    pick(x: number, y: number): MusicObject[];
+    offset(dx: number, dy: number): void;
+    updateRect(): void;
+}
+declare class ObjRest extends MusicObject {
+    readonly col: ObjRhythmColumn;
+    readonly voiceId: number;
+    readonly ownStemDir: Stem.Up | Stem.Down;
+    readonly ownDiatonicId: number;
+    readonly color: string;
+    readonly hide: boolean;
+    readonly rhythmProps: RhythmProps;
+    private beamGroup?;
+    readonly staffObjects: ObjStaffRest[];
+    readonly mi: MRest;
+    constructor(col: ObjRhythmColumn, voiceId: number, noteLength: NoteLength, options?: RestOptions);
+    getMusicInterface(): MRest;
+    get doc(): ObjDocument;
+    get measure(): ObjMeasure;
+    get row(): ObjScoreRow;
+    get noteLength(): NoteLength;
+    get dotted(): boolean;
+    get stemDir(): Stem.Up | Stem.Down;
+    get triplet(): boolean;
+    pick(x: number, y: number): MusicObject[];
+    getBeamGroup(): ObjBeamGroup | undefined;
+    setBeamGroup(beam: ObjBeamGroup): void;
+    resetBeamGroup(): void;
+    getBeamCoords(): ({
+        staff: ObjStaff;
+        x: number;
+        y: number;
+        stemHeight: number;
+    } | undefined)[];
+    isEmpty(): boolean;
+    visibleInStaff(staff: ObjStaff): boolean;
+    private getRestDotVerticalDisplacement;
+    updateAccidentalState(accState: AccidentalState): void;
+    layout(renderer: Renderer, accState: AccidentalState): void;
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+type ScorePlayerNote = {
+    note: Note;
+    ticks: number;
+    staccato: boolean;
+    slur: undefined | "first" | "slurred";
+};
+type RhythmSymbol = ObjNoteGroup | ObjRest;
+declare class ObjRhythmColumn extends MusicObject {
+    readonly measure: ObjMeasure;
+    readonly positionTicks: number;
+    private readonly voiceSymbol;
+    private minDiatonicId?;
+    private maxDiatonicId?;
+    private staffMinDiatonicId;
+    private staffMaxDiatonicId;
+    private arpeggioDir;
+    private arpeggios;
+    private noteHeadDisplacements;
+    private readonly playerProps;
+    private needLayout;
+    private shapeRects;
+    readonly mi: MRhythmColumn;
+    constructor(measure: ObjMeasure, positionTicks: number);
+    getMusicInterface(): MRhythmColumn;
+    getPlayerProps(): PlayerColumnProps;
+    /**
+     * Get next column in column's measure.
+     * @returns
+     */
+    getNextColumnInMeasure(): ObjRhythmColumn | undefined;
+    /**
+     * Get next column. Goes into next measure if necessary.
+     * Does not care navigation elements: repeats, endings, etc.
+     * @returns
+     */
+    getNextColumn(): ObjRhythmColumn | undefined;
+    getTicksToNextColumn(): number;
+    getShapeRects(): DivRect[];
+    get doc(): ObjDocument;
+    get row(): ObjScoreRow;
+    pick(x: number, y: number): MusicObject[];
+    hasArpeggio(): boolean;
+    getArpeggioDir(): Arpeggio;
+    setVoiceSymbol(voiceId: number, symbol: RhythmSymbol): void;
+    getVoiceSymbol(voiceId: number): RhythmSymbol | undefined;
+    getMinWidth(): number;
+    setupNoteHeadDisplacements(): void;
+    getNoteHeadDisplacement(noteGroup: ObjNoteGroup, note: Note): -1 | 0 | 1;
+    isEmpty(): boolean;
+    getPlayerNotes(): ScorePlayerNote[];
+    requestLayout(): void;
+    layout(renderer: Renderer, accState: AccidentalState): void;
+    layoutDone(): void;
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+type PlayerColumn = ObjRhythmColumn | ObjBarLineRight;
+declare class PlayerColumnProps {
+    readonly col: PlayerColumn;
+    private speed;
+    private volume;
+    constructor(col: PlayerColumn);
+    get measure(): ObjMeasure;
+    reset(): void;
+    setSpeed(speed: number): void;
+    getSpeed(): number;
+    getTempo(): Tempo;
+    setVolume(volume: number): void;
+    getVolume(): number;
+    hasFermata(): boolean;
+    getFermataHoldTicks(): number;
+}
+
+declare enum BarLineType {
+    None = 0,
+    Single = 1,
+    Double = 2,
+    EndSong = 3,
+    StartRepeat = 4,
+    EndRepeat = 5,
+    EndStartRepeat = 6
+}
+declare class ObjStaffTabBarLine extends MusicObject {
+    readonly line: ObjStaff | ObjTab;
+    lineRects: DivRect[];
+    dotRects: DivRect[];
+    readonly mi: MStaffTabBarLine;
+    constructor(line: ObjStaff | ObjTab);
+    getMusicInterface(): MusicInterface;
+    pick(x: number, y: number): MusicObject[];
+    setRect(r: DivRect): void;
+    offset(dx: number, dy: number): void;
+}
+declare abstract class ObjBarLine extends MusicObject {
+    readonly measure: ObjMeasure;
+    protected staffTabObjects: ObjStaffTabBarLine[];
+    protected barLineType: BarLineType;
+    constructor(measure: ObjMeasure);
+    abstract solveBarLineType(): BarLineType;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+declare class ObjBarLineLeft extends ObjBarLine {
+    readonly mi: MBarLineLeft;
+    constructor(measure: ObjMeasure);
+    getMusicInterface(): MBarLineLeft;
+    solveBarLineType(): BarLineType;
+}
+declare class ObjBarLineRight extends ObjBarLine {
+    private readonly playerProps;
+    readonly mi: MBarLineRight;
+    constructor(measure: ObjMeasure);
+    getMusicInterface(): MBarLineRight;
+    getPlayerProps(): PlayerColumnProps;
+    solveBarLineType(): BarLineType;
+}
+
+declare class ObjConnective extends MusicObject {
+    readonly connectiveProps: ConnectiveProps;
+    readonly line: ObjStaff | ObjTab;
+    readonly measure: ObjMeasure;
+    private lx;
+    private ly;
+    private rx;
+    private ry;
+    private cp1x;
+    private cp1y;
+    private cp2x;
+    private cp2y;
+    private arcHeight;
+    private readonly leftNoteGroup;
+    private readonly leftNoteId;
+    private readonly rightNoteGroup?;
+    private readonly rightNoteId?;
+    private readonly tieType?;
+    readonly mi: MConnective;
+    constructor(connectiveProps: ConnectiveProps, line: ObjStaff | ObjTab, measure: ObjMeasure, leftNoteGroup: ObjNoteGroup, leftNoteId: number, rightNoteGroup: ObjNoteGroup, rightNoteId: number);
+    constructor(connectiveProps: ConnectiveProps, line: ObjStaff | ObjTab, measure: ObjMeasure, leftNoteGroup: ObjNoteGroup, leftNoteId: number, tie: TieType);
+    getMusicInterface(): MConnective;
+    isInsideMeasure(): boolean;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjMeasure extends MusicObject {
+    readonly row: ObjScoreRow;
+    static readonly MinFlexContentWidth = 10;
+    private prevMeasure;
+    private nextMeasure;
+    private keySignature;
+    private timeSignature;
+    private tempo;
+    private alterKeySignature?;
+    private alterTimeSignature?;
+    private alterTempo?;
+    private signatures;
+    private tabStringNotes;
+    private barLineLeft;
+    private columns;
+    private barLineRight;
+    private connectives;
+    private beamGroups;
+    private tabStringNotesWidth;
+    private measureId;
+    private needLayout;
+    private leftSolidAreaWidth;
+    private minColumnsAreaWidth;
+    private rightSolidAreaWidth;
+    private useDiatonicId;
+    private useStemDir;
+    private useString;
+    private voiceSymbols;
+    private lastAddedRhythmColumn?;
+    private lastAddedRhythmSymbol?;
+    private addExtensionToMusicObject?;
+    private layoutObjects;
+    private postMeasureBreakWidth;
+    private passCount;
+    private needBeamsUpdate;
+    private navigationSet;
+    private isEndSong;
+    private isEndSection;
+    private endRepeatPlayCount;
+    private endRepeatPlayCountText?;
+    readonly mi: MMeasure;
+    constructor(row: ObjScoreRow);
+    getMusicInterface(): MMeasure;
+    get doc(): ObjDocument;
+    isPartialMeasure(): boolean;
+    isUpBeat(): boolean;
+    resetPassCount(): void;
+    incPassCount(): void;
+    getPassCount(): number;
+    updateOwnDiatonicId(voiceId: number, setDiatonicId?: number): number;
+    updateOwnStemDir(symbol: RhythmSymbol, setStemDir?: Stem): Stem.Up | Stem.Down;
+    updateOwnString(symbol: RhythmSymbol, setString?: StringNumber[]): StringNumber[];
+    pick(x: number, y: number): MusicObject[];
+    getMeasureNumber(): number;
+    getColumns(): ReadonlyArray<ObjRhythmColumn>;
+    getColumnCount(): number;
+    getColumn(columnId: number): ObjRhythmColumn | undefined;
+    isFirstMeasure(): boolean;
+    isLastMeasure(): boolean;
+    getNextMeasure(): ObjMeasure | undefined;
+    getPrevMeasure(): ObjMeasure | undefined;
+    getKeySignature(): KeySignature;
+    setKeySignature(...args: unknown[]): void;
+    updateKeySignature(): void;
+    getTimeSignature(): TimeSignature;
+    setTimeSignature(timeSignature: TimeSignature | TimeSignatureString): void;
+    updateTimeSignature(): void;
+    getTempo(): Tempo;
+    setTempo(beatsPerMinute: number, beatLength?: NoteLength, dotted?: boolean): void;
+    updateTempo(): void;
+    hasPostMeasureBreak(): boolean;
+    getPostMeasureBreakWidth(): number;
+    private addLayoutObject;
+    addFermata(fermata: Fermata): void;
+    hasFermata(anchor: ObjRhythmColumn | ObjBarLineRight): boolean;
+    addNavigation(navigation: Navigation, ...args: unknown[]): void;
+    hasNavigation(n: Navigation): boolean;
+    getEnding(): ObjEnding | undefined;
+    getEndRepeatPlayCount(): number;
+    addConnective(connective: Connective.Tie, tieSpan?: number | TieType, notAnchor?: NoteAnchor): void;
+    addConnective(connective: Connective.Slur, slurSpan?: number, notAnchor?: NoteAnchor): void;
+    addConnective(connective: Connective.Slide, notAnchor?: NoteAnchor): void;
+    addLabel(label: Label, text: string): void;
+    addAnnotation(annotation: Annotation, text: string): void;
+    endSong(): void;
+    hasEndSong(): boolean;
+    endSection(): void;
+    hasEndSection(): boolean;
+    endRow(): void;
+    private enableExtension;
+    private disableExtension;
+    addExtension(extensionLength: number, extensionVisible: boolean): void;
+    private addRhythmSymbol;
+    addNoteGroup(voiceId: number, notes: (Note | string)[], noteLength: NoteLength, options?: NoteOptions): void;
+    addRest(voiceId: number, restLength: NoteLength, options?: RestOptions): void;
+    /**
+     *
+     * @param positionTicks - get ObjRhythmColumn with positionTicks. Insert new if necessary.
+     * @returns
+     */
+    private getRhythmColumn;
+    getMeasureTicks(): number;
+    getConsumedTicks(voiceId?: number): number;
+    getColumnsContentRect(): DivRect;
+    getLeftSolidAreaWidth(): number;
+    getMinColumnsAreaWidth(): number;
+    getRightSolidAreaWidth(): number;
+    getSolidAreaWidth(): number;
+    getMinWidth(): number;
+    getStaffLineLeft(): number;
+    getStaffLineRight(): number;
+    getStaticObjects(): ReadonlyArray<ObjRhythmColumn | LayoutableMusicObject>;
+    removeLayoutObjects(musicObj: MusicObject): void;
+    addConnectiveObject(connective: ObjConnective): void;
+    removeConnectiveObjects(): void;
+    createExtensions(): void;
+    addBeamGroup(beam: ObjBeamGroup): void;
+    requestBeamsUpdate(): void;
+    createBeams(): void;
+    private static setupBeamGroup;
+    getBarLineLeft(): ObjBarLineLeft;
+    getBarLineRight(): ObjBarLineRight;
+    getVoiceSymbols(voiceId: number): ReadonlyArray<RhythmSymbol>;
+    completeRests(voiceId?: number): void;
+    requestLayout(): void;
+    layout(renderer: Renderer): void;
+    layoutWidth(renderer: Renderer, width: number): void;
+    layoutConnectives(renderer: Renderer): void;
+    layoutBeams(renderer: Renderer): void;
+    alignStemsToBeams(): void;
+    layoutDone(): void;
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjScoreRow extends MusicObject {
+    readonly doc: ObjDocument;
+    private readonly prevRow;
+    private readonly scoreConfig;
+    private nextRow?;
+    private minWidth;
+    private readonly notationLines;
+    private readonly staves;
+    private readonly tabs;
+    private readonly measures;
+    private needLayout;
+    readonly mi: MScoreRow;
+    constructor(doc: ObjDocument, prevRow: ObjScoreRow | undefined, scoreConfig: (StaffConfig | TabConfig)[]);
+    getMusicInterface(): MScoreRow;
+    private createNotationLines;
+    getNotationLines(): ReadonlyArray<ObjStaff | ObjTab>;
+    getStaves(): ReadonlyArray<ObjStaff>;
+    getTabs(): ReadonlyArray<ObjTab>;
+    get hasStaff(): boolean;
+    get hasTab(): boolean;
+    getTopStaff(): ObjStaff;
+    getBottomStaff(): ObjStaff;
+    getStaff(diatonicId: number): ObjStaff | undefined;
+    pick(x: number, y: number): MusicObject[];
+    getConnectivesContentRect(): DivRect;
+    getDiatonicIdAt(y: number): number | undefined;
+    addMeasure(m: ObjMeasure): void;
+    getMeasures(): ReadonlyArray<ObjMeasure>;
+    isFirstRow(): boolean;
+    isLastRow(): boolean;
+    getPrevRow(): ObjScoreRow | undefined;
+    getNextRow(): ObjScoreRow | undefined;
+    getFirstMeasure(): ObjMeasure | undefined;
+    getLastMeasure(): ObjMeasure | undefined;
+    getMinWidth(): number;
+    requestLayout(): void;
+    layout(renderer: Renderer): void;
+    layoutWidth(renderer: Renderer, width: number): void;
+    alignStemsToBeams(): void;
+    layoutPositionLines(renderer: Renderer): void;
+    updateRect(): void;
+    private setObjectY;
+    private alignObjectsY;
+    layoutLayoutGroup(renderer: Renderer, layoutGroup: LayoutGroup, verticalPos: VerticalPos): void;
+    layoutPadding(renderer: Renderer): void;
+    layoutDone(): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjDocument extends MusicObject {
+    private needLayout;
+    private renderer?;
+    private readonly rows;
+    private readonly measures;
+    private measuresPerRow;
+    private curScoreConfig;
+    private header?;
+    private layoutGroups;
+    private newRowRequested;
+    private allConnectiveProps;
+    private readonly mi;
+    constructor();
+    getMusicInterface(): MDocument;
+    setScoreConfiguration(config: StaffPreset | ScoreConfiguration): void;
+    setMeasuresPerRow(measuresPerRow: number): void;
+    addConnectiveProps(connectiveProps: ConnectiveProps): void;
+    getLayoutGroup(lauoutGroupId: LayoutGroupId): LayoutGroup;
+    setRenderer(renderer?: Renderer): void;
+    setHeader(title?: string, composer?: string, arranger?: string): void;
+    getTitle(): string | undefined;
+    getComposer(): string | undefined;
+    getArranger(): string | undefined;
+    hasSingleMeasure(): boolean;
+    getFirstMeasure(): ObjMeasure | undefined;
+    getLastMeasure(): ObjMeasure | undefined;
+    private addNewRow;
+    getFirstRow(): ObjScoreRow;
+    getLastRow(): ObjScoreRow;
+    requestNewRow(): void;
+    addMeasure(): ObjMeasure;
+    getVoiceSymbols(voiceId: number): ReadonlyArray<RhythmSymbol>;
+    removeLayoutObjects(musicObj: MusicObject): void;
+    private forEachMeasure;
+    resetMeasures(): void;
+    updateCursorRect(cursorRect?: DivRect): void;
+    requestLayout(): void;
+    requestFullLayout(): void;
+    layout(): void;
+    drawContent(): void;
+    pickStaffPosAt(x: number, y: number): {
+        scoreRow: ObjScoreRow;
+        diatonicId: number;
+    } | undefined;
+    pick(x: number, y: number): MusicObject[];
+}
+
+declare enum ImageAsset {
+    TrebleClefPng = 0,
+    BassClefPng = 1
+}
+declare class Renderer {
+    private readonly mi;
+    readonly devicePixelRatio: number;
+    readonly fontSize: number;
+    readonly unitSize: number;
+    readonly lineWidth: number;
+    readonly beamThickness: number;
+    private scoreEventListener?;
+    private canvas?;
+    private ctx?;
+    private mdoc?;
+    private cursorRect?;
+    private mousePos?;
+    private curStaffPos?;
+    private curObjects?;
+    private hilightedStaffPos?;
+    private hilightedObj?;
+    private usingTouch;
+    private onClickFn;
+    private onMouseMoveFn;
+    private onMouseLeaveFn;
+    private onTouchEndFn;
+    constructor(mi: MRenderer);
+    getMusicInterface(): MRenderer;
+    get doc(): ObjDocument | undefined;
+    private finishImageAsset;
+    getImageAsset(imageAsset: ImageAsset): HTMLImageElement | undefined;
+    setDocument(mdoc?: MDocument): void;
+    setCanvas(canvas: HTMLCanvasElement): void;
+    setScoreEventListener(fn: ScoreEventListener): void;
+    needMouseInput(): boolean;
+    getMousePos(e: MouseEvent): Vec2;
+    private updateCurStaffPos;
+    private updateCurObjects;
+    onClick(e: MouseEvent): void;
+    onMouseMove(e: MouseEvent): void;
+    onMouseLeave(e: MouseEvent): void;
+    onTouchEnd(e: TouchEvent): void;
+    onLoad(): void;
+    hilightObject(obj?: MusicObject): void;
+    hilightStaffPos(staffPos?: {
+        scoreRow: ObjScoreRow;
+        diatonicId: number;
+    }): void;
+    updateCursorRect(cursorRect: DivRect | undefined): void;
+    updateCanvasSize(): void;
+    draw(): void;
+    drawHilightStaffPosRect(): void;
+    drawHilightObjectRect(): void;
+    drawPlayCursor(): void;
+    txFromScreenCoord(screenCoord: Vec2): Vec2;
+    txToScreenCoord(coord: Vec2): Vec2;
+    getCanvasContext(): CanvasRenderingContext2D | undefined;
+    clearCanvas(): void;
+    getTextWidth(text: string, font: string): number;
+    drawDebugRect(r: DivRect): void;
+    fillCircle(x: number, y: number, radius: number, color?: string): void;
+    drawLine(startX: number, startY: number, endX: number, endY: number, color?: string, lineWidth?: number): void;
+    drawPartialLine(startX: number, startY: number, endX: number, endY: number, startT: number, endT: number, color?: string, lineWidth?: number): void;
+    drawLedgerLines(staff: ObjStaff, diatonicId: number, x: number): void;
+}
+
+declare class ObjEnding extends MusicObject {
+    readonly measure: ObjMeasure;
+    readonly passages: number[];
+    private endingText;
+    private shapeRects;
+    readonly mi: MEnding;
+    constructor(measure: ObjMeasure, passages: number[]);
+    getMusicInterface(): MEnding;
+    getShapeRects(): DivRect[];
+    isSingleMeasureEnding(): boolean;
+    hasPassage(pass: number): boolean;
+    getHighestPassage(): number;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    layoutFitToMeasure(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjFermata extends MusicObject {
+    readonly pos: VerticalPos;
+    private color;
+    readonly mi: MFermata;
+    constructor(parent: ObjRhythmColumn | ObjBarLineRight, pos: VerticalPos);
+    getMusicInterface(): MFermata;
+    static getFermataPositions(anchor: ObjRhythmColumn | ObjBarLineRight): VerticalPos[];
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjSpecialText extends MusicObject {
+    readonly text: string;
+    static toCoda: string;
+    static Coda: string;
+    static Segno: string;
+    private components;
+    readonly mi: MSpecialText;
+    constructor(parent: MusicObject, text: string);
+    getMusicInterface(): MSpecialText;
+    getText(): string;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+type ExtensionLineStyle = "solid" | "dashed";
+type ExtensionLinePos = "bottom" | "middle";
+type ExtensionRangeInfo = {
+    startColumn: ObjRhythmColumn;
+    endColumn: ObjRhythmColumn;
+    columnRange: ObjRhythmColumn[];
+    extensionBreakText?: string;
+};
+declare class Extension extends MusicObjectLink {
+    private readonly length;
+    private readonly visible;
+    private readonly lineStyle;
+    private readonly linePos;
+    private readonly startColumn;
+    private readonly context;
+    constructor(head: MusicObject, startColumn: ObjRhythmColumn, length: number, visible: boolean, lineStyle: ExtensionLineStyle, linePos: ExtensionLinePos);
+    isVisible(): boolean;
+    getLineStyle(): ExtensionLineStyle;
+    getLinePos(): ExtensionLinePos;
+    private getSpanBreakText;
+    getExtensionRangeInfo(): ExtensionRangeInfo;
+}
+
+type ExtensionLineLeftObj = ObjBarLineLeft | MusicObject;
+type ExtensionLineRightObj = ObjRhythmColumn | ObjBarLineRight;
+declare class ObjExtensionLine extends MusicObject {
+    readonly measure: ObjMeasure;
+    readonly extension: Extension;
+    readonly leftObj: ExtensionLineLeftObj;
+    readonly rightObj: ExtensionLineRightObj;
+    readonly mi: MExtensionLine;
+    constructor(measure: ObjMeasure, extension: Extension, leftObj: ExtensionLineLeftObj, rightObj: ExtensionLineRightObj);
+    get row(): ObjScoreRow;
+    getMusicInterface(): MExtensionLine;
+    private getLineLeft;
+    private getLineRight;
+    layoutFitToMeasure(renderer: Renderer): void;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare enum LayoutGroupId {
+    Fermata = 0,
+    NoteLabel = 1,
+    Navigation = 2,
+    Ending = 3,
+    TempoAnnotation = 4,
+    DynamicsAnnotation = 5,
+    ChordLabel = 6
+}
+declare enum VerticalPos {
+    AboveStaff = 0,
+    BelowStaff = 1
+}
+type LayoutableMusicObject = ObjText | ObjSpecialText | ObjExtensionLine | ObjFermata | ObjEnding;
+declare class LayoutObjectWrapper {
+    readonly musicObj: LayoutableMusicObject;
+    readonly layoutGroupId: LayoutGroupId;
+    readonly verticalPos: VerticalPos;
+    readonly anchor: MusicObject;
+    readonly measure: ObjMeasure;
+    readonly row: ObjScoreRow;
+    readonly layoutGroup: LayoutGroup;
+    private positionResolved;
+    constructor(musicObj: LayoutableMusicObject, layoutGroupId: LayoutGroupId, verticalPos: VerticalPos);
+    clearPositionResolved(): void;
+    setPositionResolved(): void;
+    isPositionResolved(): boolean;
+    resolveClosestToStaffY(renderer: Renderer): number;
+    getTextContent(): string | undefined;
+}
+declare class LayoutGroup {
+    readonly layoutGroupId: number;
+    private readonly layoutObjectTable;
+    readonly rowAlign: boolean;
+    readonly widensColumn: boolean;
+    constructor(layoutGroupId: number);
+    getLayoutObjects(verticalPos: VerticalPos): Readonly<LayoutObjectWrapper[]>;
+    add(layoutObj: LayoutObjectWrapper): void;
+    remove(layoutObj: LayoutObjectWrapper): void;
+    clearPositionAndLayout(renderer: Renderer): void;
+}
+
+declare class MusicObjectLink {
+    private head;
+    private tail;
+    constructor(head: MusicObject);
+    getHead(): MusicObject;
+    getTails(): ReadonlyArray<MusicObject>;
+    addTail(obj: MusicObject): void;
+    detachTail(obj: MusicObject): void;
+}
+declare abstract class MusicObject {
+    protected readonly parent: MusicObject | undefined;
+    private anchoredLayoutObjects;
+    private link?;
+    constructor(parent: MusicObject | undefined);
+    abstract getMusicInterface(): MusicInterface;
+    getParent(): MusicObject | undefined;
+    protected rect: DivRect;
+    private needRectUpdate;
+    requestRectUpdate(): void;
+    updateRect(): void;
+    getRect(): DivRect;
+    /**
+     * Most objects are simple rects in shape.
+     * Some objects might be more complex consisting of multiple rects.
+     * These rects are used to dodge overlapping objects.
+     *
+     * @returns Array of rects.
+     */
+    getShapeRects(): DivRect[];
+    /**
+     * Pick objects.
+     *
+     * @param x - X-coordinate.
+     * @param y - Y-coordinate.
+     * @returns Array of objects under (x, y)-coordinate in hierarchical order. Last object in array is the top-most object.
+     */
+    abstract pick(x: number, y: number): MusicObject[];
+    addAnchoredLayoutObject(layoutObj: LayoutObjectWrapper): void;
+    getAnchoredLayoutObjects(): ReadonlyArray<LayoutObjectWrapper>;
+    setLink(link: MusicObjectLink): void;
+    getLink(): MusicObjectLink | undefined;
+    isLinked(): boolean;
+}
+
+declare class ObjArpeggio extends MusicObject {
+    readonly col: ObjRhythmColumn;
+    readonly arpeggioDir: Arpeggio;
+    private topArrowHeight;
+    private bottomArrowHeight;
+    private static NumCycles;
+    private cycleHeight;
+    private color;
+    readonly mi: MArpeggio;
+    constructor(col: ObjRhythmColumn, arpeggioDir: Arpeggio);
+    getMusicInterface(): MArpeggio;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjHeader extends MusicObject {
+    readonly title?: string | undefined;
+    readonly composer?: string | undefined;
+    readonly arranger?: string | undefined;
+    private titleText?;
+    private composerText?;
+    private arrangerText?;
+    readonly mi: MHeader;
+    constructor(doc: ObjDocument, title?: string | undefined, composer?: string | undefined, arranger?: string | undefined);
+    getMusicInterface(): MHeader;
+    pick(x: number, y: number): MusicObject[];
+    layoutWidth(renderer: Renderer, width: number): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjImage extends MusicObject {
+    readonly image: HTMLImageElement;
+    readonly anchorX: number;
+    readonly anchorY: number;
+    readonly imageScale: number;
+    readonly mi: MImage;
+    constructor(parent: MusicObject, image: HTMLImageElement, anchorX: number, anchorY: number, imageScale: number);
+    getMusicInterface(): MImage;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+declare class ObjSignature extends MusicObject {
+    readonly measure: ObjMeasure;
+    readonly staff: ObjStaff;
+    private clefImage?;
+    private eightBelowClef?;
+    private measureNumber?;
+    private ksNeutralizeAccidentals;
+    private ksNewAccidentals;
+    private beatCountText?;
+    private beatSizeText?;
+    private tempoText?;
+    readonly mi: MSignature;
+    constructor(measure: ObjMeasure, staff: ObjStaff);
+    getMusicInterface(): MSignature;
+    updateClefImage(renderer: Renderer, showClef: boolean): void;
+    updateMeasureNumber(showMeasureNumber: boolean): void;
+    updateKeySignature(showKeySignature: boolean): void;
+    updateTimeSignature(showTimeSignature: boolean): void;
+    updateTempo(showTempo: boolean): void;
+    private getAccidentalDiatonicId;
+    pick(x: number, y: number): MusicObject[];
+    layout(renderer: Renderer): void;
+    offset(dx: number, dy: number): void;
+    draw(renderer: Renderer): void;
+}
+
+/** @public */
+type ScoreEventType = "enter" | "leave" | "click";
+/** @public */
+declare abstract class ScoreEvent {
+    readonly type: ScoreEventType;
+    constructor(type: ScoreEventType);
+}
+/** @public */
+declare class ScoreStaffPosEvent extends ScoreEvent {
+    readonly renderer: MRenderer;
+    readonly scoreRow: MScoreRow;
+    readonly diatonicId: number;
+    constructor(type: ScoreEventType, renderer: MRenderer, scoreRow: MScoreRow, diatonicId: number);
+}
+/** @public */
+declare class ScoreObjectEvent extends ScoreEvent {
+    readonly renderer: MRenderer;
+    readonly objects: MusicInterface[];
+    constructor(type: ScoreEventType, renderer: MRenderer, objects: MusicInterface[]);
+    get topObject(): MusicInterface;
+    findObject(fn: (obj: MusicInterface) => boolean): MusicInterface | undefined;
+}
+/** @public */
+type ScoreEventListener = (event: ScoreEvent) => void;
+
+/** @public */
+declare abstract class MusicInterface {
+    readonly name: string;
+    constructor(name: string);
+    /** @internal */
+    abstract getMusicObject(): MusicObject;
+    getParent(): MusicInterface | undefined;
+}
+/** @public */
+declare class MAccidental extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Accidental";
+    /** @internal */
+    constructor(obj: ObjAccidental);
+    /** @internal */
+    getMusicObject(): ObjAccidental;
+    getAccidental(): Accidental;
+}
+/** @public */
+declare class MConnective extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Connective";
+    /** @internal */
+    constructor(obj: ObjConnective);
+    /** @internal */
+    getMusicObject(): ObjConnective;
+}
+/** @public */
+declare class MArpeggio extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Arpeggio";
+    /** @internal */
+    constructor(obj: ObjArpeggio);
+    /** @internal */
+    getMusicObject(): ObjArpeggio;
+}
+/** @public */
+declare class MBeamGroup extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "BeamGroup";
+    /** @internal */
+    constructor(obj: ObjBeamGroup);
+    /** @internal */
+    getMusicObject(): ObjBeamGroup;
+}
+/** @public */
+declare class MStaffBeamGroup extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "StaffBeamGroup";
+    /** @internal */
+    constructor(obj: ObjStaffBeamGroup);
+    /** @internal */
+    getMusicObject(): ObjStaffBeamGroup;
+}
+/** @public */
+declare class MDocument extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Document";
+    /** @internal */
+    constructor(obj: ObjDocument);
+    /** @internal */
+    getMusicObject(): ObjDocument;
+    getTitle(): string | undefined;
+    getComposer(): string | undefined;
+    getArranger(): string | undefined;
+    play(fn?: PlayStateChangeListener): MPlayer;
+}
+/** @public */
+declare class MEnding extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Ending";
+    /** @internal */
+    constructor(obj: ObjEnding);
+    /** @internal */
+    getMusicObject(): ObjEnding;
+    getPassages(): ReadonlyArray<number>;
+    hasPassage(passage: number): boolean;
+}
+/** @public */
+declare class MFermata extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Fermata";
+    /** @internal */
+    constructor(obj: ObjFermata);
+    /** @internal */
+    getMusicObject(): ObjFermata;
+}
+/** @public */
+declare class MHeader extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Header";
+    /** @internal */
+    constructor(obj: ObjHeader);
+    /** @internal */
+    getMusicObject(): ObjHeader;
+    getTitle(): string | undefined;
+    getComposer(): string | undefined;
+    getArranger(): string | undefined;
+}
+/** @public */
+declare class MImage extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Image";
+    /** @internal */
+    constructor(obj: ObjImage);
+    /** @internal */
+    getMusicObject(): ObjImage;
+}
+/** @public */
+declare class MMeasure extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Measure";
+    /** @internal */
+    constructor(obj: ObjMeasure);
+    /** @internal */
+    getMusicObject(): ObjMeasure;
+    getMeasureNumber(): number;
+    getRhythmColumns(): ReadonlyArray<MRhythmColumn>;
+}
+/** @public */
+declare class MBarLineRight extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "BarLineRight";
+    /** @internal */
+    constructor(obj: ObjBarLineRight);
+    /** @internal */
+    getMusicObject(): ObjBarLineRight;
+}
+/** @public */
+declare class MBarLineLeft extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "BarLineLeft";
+    /** @internal */
+    constructor(obj: ObjBarLineLeft);
+    /** @internal */
+    getMusicObject(): ObjBarLineLeft;
+}
+/** @public */
+declare class MStaffTabBarLine extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "StaffTabBarLine";
+    /** @internal */
+    constructor(obj: ObjStaffTabBarLine);
+    /** @internal */
+    getMusicObject(): ObjStaffTabBarLine;
+}
+/** @public */
+declare class MNoteGroup extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "NoteGroup";
+    /** @internal */
+    constructor(obj: ObjNoteGroup);
+    /** @internal */
+    getMusicObject(): ObjNoteGroup;
+    getNotes(): ReadonlyArray<Note>;
+    getRhythmProps(): RhythmProps;
+}
+/** @public */
+declare class MStaffNoteGroup extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "StaffNoteGroup";
+    /** @internal */
+    constructor(obj: ObjStaffNoteGroup);
+    /** @internal */
+    getMusicObject(): ObjStaffNoteGroup;
+    getNoteGroup(): MNoteGroup;
+}
+/** @public */
+declare class MTabNoteGroup extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "TabNoteGroup";
+    /** @internal */
+    constructor(obj: ObjTabNoteGroup);
+    /** @internal */
+    getMusicObject(): ObjTabNoteGroup;
+    getNoteGroup(): MNoteGroup;
+}
+/** @public */
+declare class MRest extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Rest";
+    /** @internal */
+    constructor(obj: ObjRest);
+    /** @internal */
+    getMusicObject(): ObjRest;
+    getRhythmProps(): RhythmProps;
+}
+/** @public */
+declare class MStaffRest extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "StaffRest";
+    /** @internal */
+    constructor(obj: ObjStaffRest);
+    /** @internal */
+    getMusicObject(): ObjStaffRest;
+    getRest(): MRest;
+}
+/** @public */
+declare class MRhythmColumn extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "RhythmColumn";
+    /** @internal */
+    constructor(obj: ObjRhythmColumn);
+    /** @internal */
+    getMusicObject(): ObjRhythmColumn;
+    getRhythmSymbol(voiceId: number): MNoteGroup | MRest | undefined;
+}
+/** @public */
+declare class MScoreRow extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "ScoreRow";
+    /** @internal */
+    constructor(obj: ObjScoreRow);
+    /** @internal */
+    getMusicObject(): ObjScoreRow;
+    getMeasures(): ReadonlyArray<MMeasure>;
+}
+/** @public */
+declare class MStaff extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Staff";
+    /** @internal */
+    constructor(obj: ObjStaff);
+    /** @internal */
+    getMusicObject(): ObjStaff;
+}
+/** @public */
+declare class MTab extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Tab";
+    /** @internal */
+    constructor(obj: ObjTab);
+    /** @internal */
+    getMusicObject(): ObjTab;
+}
+/** @public */
+declare class MSignature extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Signature";
+    /** @internal */
+    constructor(obj: ObjSignature);
+    /** @internal */
+    getMusicObject(): ObjSignature;
+}
+/** @public */
+declare class MSpecialText extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "SpecialText";
+    /** @internal */
+    constructor(obj: ObjSpecialText);
+    /** @internal */
+    getMusicObject(): ObjSpecialText;
+}
+/** @public */
+declare class MText extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Text";
+    /** @internal */
+    constructor(obj: ObjText);
+    /** @internal */
+    getMusicObject(): ObjText;
+    getText(): string;
+}
+/** @public */
+declare class MExtensionLine extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "ExtensionLine";
+    /** @internal */
+    constructor(obj: ObjExtensionLine);
+    /** @internal */
+    getMusicObject(): ObjExtensionLine;
+}
+/** @public */
+declare class MPlayer {
+    private static currentlyPlaying;
+    private readonly player;
+    constructor(doc: MDocument, fn?: PlayStateChangeListener);
+    static stopAll(): void;
+    play(): this;
+    pause(): this;
+    stop(): this;
+}
+/** @public */
+declare class MRenderer {
+    private readonly renderer;
+    constructor();
+    setDocument(doc?: MDocument): this;
+    setCanvas(canvas: HTMLCanvasElement | string): this;
+    setScoreEventListener(fn: ScoreEventListener): void;
+    hilightObject(obj?: MusicInterface): void;
+    hilightStaffPos(staffPos?: {
+        scoreRow: MScoreRow;
+        diatonicId: number;
+    }): void;
+    draw(): void;
+}
+/** @public */
+declare class MPlaybackButtons {
+    private playButton?;
+    private stopButton?;
+    private playStopButton?;
+    private pauseButton?;
+    private onPlay;
+    private onStop;
+    private onPlayStop;
+    private onPause;
+    private playLabel;
+    private stopLabel;
+    private pauseLabel;
+    private playState;
+    private player?;
+    constructor();
+    setDocument(doc?: MDocument): this;
+    detachDocument(): void;
+    private updateButtons;
+    setPlayButton(btn: HTMLButtonElement | string, btnLabel?: string): this;
+    setStopButton(btn: HTMLButtonElement | string, btnLabel?: string): this;
+    setPlayStopButton(btn: HTMLButtonElement | string, playLabel?: string, stopLabel?: string): this;
+    setPauseButton(btn: HTMLButtonElement | string, btnLabel?: string): this;
+    private static savedOnClickListeners;
+    private static removeOnClickListeners;
+    private static addOnClickListener;
+}
+
+export { getVoiceIds as $, Annotation as A, MStaffRest as B, Connective as C, DivRect as D, MRhythmColumn as E, Fermata as F, MScoreRow as G, MStaff as H, MTab as I, MSignature as J, MSpecialText as K, Label as L, MDocument as M, type NoteOptions as N, ObjMeasure as O, MText as P, MExtensionLine as Q, type RestOptions as R, StaffPreset as S, TieType as T, MPlayer as U, MRenderer as V, MPlaybackButtons as W, Clef as X, type StaffConfig as Y, type TabConfig as Z, type VoiceId as _, type ScoreConfiguration as a, type StringNumber as a0, getStringNumbers as a1, Stem as a2, Arpeggio as a3, type ConnectiveSpan as a4, PlayState as a5, type PlayStateChangeListener as a6, Navigation as b, NoteAnchor as c, type ScoreEventType as d, ScoreEvent as e, ScoreStaffPosEvent as f, ScoreObjectEvent as g, type ScoreEventListener as h, MusicInterface as i, MAccidental as j, MConnective as k, MArpeggio as l, MBeamGroup as m, MStaffBeamGroup as n, MEnding as o, MFermata as p, MHeader as q, MImage as r, MMeasure as s, MBarLineRight as t, MBarLineLeft as u, MStaffTabBarLine as v, MNoteGroup as w, MStaffNoteGroup as x, MTabNoteGroup as y, MRest as z };