web-music-score 0.0.1 → 6.0.0-pre.1

package/dist/music-objects-DLmp5uL6.d.ts

@@ -0,0 +1,2398 @@
+import { N as Note, A as Accidental } from './note-RVXvpfyV.js';
+import { R as RhythmProps, N as NoteLength, h as NoteLengthStr, k as TupletRatio, c as Tempo, K as KeySignature, a as TimeSignature } from './tempo-D-JF-8b_.js';
+import { AnchoredRect, UniMap, Rect, Vec } from '@tspro/ts-utils-lib';
+
+/** Staff preset values for score configuration. */
+declare enum StaffPreset {
+    /** Treble staff has treble (G-) clef. */
+    Treble = "treble",
+    /** Bass staff has bass (F-) clef. */
+    Bass = "bass",
+    /** Grand staff has both treble and bass clefs. */
+    Grand = "grand",
+    /** GuitarTreble has treble clef but is one octave lower. */
+    GuitarTreble = "guitarTreble",
+    /** GuitarTab has tab for guitar. */
+    GuitarTab = "guitarTab",
+    /** GuitarCombined has treble clef and tab for guitar. */
+    GuitarCombined = "guitarCombined"
+}
+/** Clef for staff notation lines. */
+declare enum Clef {
+    /** G-clef (treble cleff) */
+    G = "G",
+    /** F-clef (bass cleff) */
+    F = "F"
+}
+/** Base config for staff and tab configs. */
+type BaseConfig = {
+    /** Name for this staff/tab config. */
+    name?: string;
+    /** Voice id that is presented in this staff/tab. Single value or array.*/
+    voiceId?: VoiceId | VoiceId[];
+    /**
+     * Instrument name for this staf/tab.<br />
+     * Consecutive staves/tabs with the same name are grouped together.<br />
+     * Hint!<br />
+     * `"!Piano"` hides name.<br />
+     * `"!{Piano"` hides both name and left brace of the group.
+     * */
+    instrument?: string;
+};
+/** Staff config to add staff notation line in score configuration. */
+type StaffConfig = BaseConfig & {
+    /** Config type, must be "staff" for staff config. */
+    type: "staff";
+    /** G-clef or F-clef for this staff config? */
+    clef: Clef | `${Clef}`;
+    /** Set octave down with G-clef for guitar treble staff notation line. */
+    isOctaveDown?: boolean;
+    /** Lowest note (e.g. "C2")that can be presented in this staff notation line. */
+    minNote?: string;
+    /** Highest note (e.g. "C6") that can be presented in this staff notation line. */
+    maxNote?: string;
+    /**
+     * To create grand staff: use same `grandId` value (e.g. "grand1") for two
+     * consequtive staves, first having G-clef and second having F-clef.
+     */
+    grandId?: string;
+};
+/** Tab config to add guitar tab in score configuration. */
+type TabConfig = BaseConfig & {
+    /** Config type, must be "tab" for tab config. */
+    type: "tab";
+    /** Tuning name or array six notes (tune for each string). */
+    tuning?: string | string[];
+};
+/** Score configuration. */
+type ScoreConfiguration = StaffConfig | TabConfig | (StaffConfig | TabConfig)[];
+/** Voice id. */
+type VoiceId = 0 | 1 | 2 | 3;
+/** Get supported voice ids. Returns [0, 1, 2, 3]. */
+declare function getVoiceIds(): ReadonlyArray<VoiceId>;
+declare function isVoiceId(voiceId: unknown): voiceId is VoiceId;
+declare function validateVoiceId(voiceId: unknown): VoiceId;
+/** Strng number. */
+type StringNumber = 1 | 2 | 3 | 4 | 5 | 6;
+/** Get string numbers. Returns [0, 1, 2, 3, 4, 5]. */
+declare function getStringNumbers(): ReadonlyArray<StringNumber>;
+declare function isStringNumber(stringNum: unknown): stringNum is VerseNumber;
+declare function validateStringNumber(stringNum: unknown): VerseNumber;
+/** Verse number. */
+type VerseNumber = 1 | 2 | 3;
+/** Get supported verse numbers. Returns [1, 2, 3]. */
+declare function getVerseNumbers(): ReadonlyArray<VerseNumber>;
+declare function isVerseNumber(verse: unknown): verse is VerseNumber;
+declare function validateVerseNumber(verseNum: unknown): VerseNumber;
+/** Stem direction enum. */
+declare enum Stem {
+    /** Auto stem direction. */
+    Auto = "auto",
+    /** Stem is upwards. */
+    Up = "up",
+    /** Stm is downwards. */
+    Down = "down"
+}
+/** Arpeggio direction enum. */
+declare enum Arpeggio {
+    /** Upwards, chord played from lowes to highest. */
+    Up = "up",
+    /** Downwards, chord played from highest to loest. */
+    Down = "down"
+}
+/** Special tie length enum. */
+declare enum TieType {
+    /** Stub tie is short tie that left anchors to note and has not right anchor point. */
+    Stub = "stub",
+    /** To measure end tie is tie that left anchors to note and right anchors to measure end. */
+    ToMeasureEnd = "toMeasureEnd"
+}
+/** Anchor point enum for connectives (ties, slurs, slides). */
+declare enum NoteAnchor {
+    /** Automatically choose anchor point using simple logic. */
+    Auto = "auto",
+    /** Anchor connective above note head. */
+    Above = "above",
+    /** Anchor connective center/next to note head.*/
+    Center = "center",
+    /** Anchor connective below note head. */
+    Below = "below",
+    /** Anchor connective to stem tip. */
+    StemTip = "stemTip"
+}
+/** Connective enum. */
+declare enum Connective {
+    /** Tie, connects two or more adjacent notes of same pitch with arc. */
+    Tie = "tie",
+    /** Slur, connects two or more adjacent notes of different pitch with arc. */
+    Slur = "slur",
+    /** Slide, connects two adjacent notes of different pitch with straight line. */
+    Slide = "slide"
+}
+/** Vertical position enum used to layout notation elements. */
+declare enum VerticalPosition {
+    /** Automatic/default layout position depending on element. */
+    Auto = "auto",
+    /** Add  element above staff/tab. */
+    Above = "above",
+    /** Add element below staff/tab. */
+    Below = "below",
+    /** Add element both above and below staff/tab. */
+    Both = "both"
+}
+/** Staff/tab/group type can be staff/tab index or staff/tab/group name. */
+type StaffTabOrGroup = number | string;
+/** Staff/tab/group snglevalue or array of values. */
+type StaffTabOrGroups = StaffTabOrGroup | StaffTabOrGroup[];
+/** Measure options. */
+type MeasureOptions = {
+    /** show measure number? */
+    showNumber?: boolean;
+};
+/** Options for notes/chords. */
+type NoteOptions = {
+    /** Stem direction. */
+    stem?: Stem | `${Stem}`;
+    /** Set color. */
+    color?: string;
+    /** Arepggio direction for chords. true = "up". */
+    arpeggio?: boolean | Arpeggio | `${Arpeggio}`;
+    /** Add staccato dot. */
+    staccato?: boolean;
+    /** Use diamond shaped note head. */
+    diamond?: boolean;
+    /** Set string number (array of numbers for chord) to use in guitar tab. */
+    string?: StringNumber | StringNumber[];
+};
+/** Options for rests. */
+type RestOptions = {
+    /** Set staff position for this rest. Can be instance of Note, string (e.g. "C3"), or midiNumber. */
+    staffPos?: Note | string | number;
+    /** Set color. */
+    color?: string;
+    /** Hide this rest, still affects playing. */
+    hide?: boolean;
+};
+/** Tuplet options. */
+type TupletOptions = {
+    /** Show tuplet ratio (e.g. "3:2") instead of number of parts (e.g. "3"). */
+    showRatio?: boolean;
+};
+/** Lyrics text/syllable alignment.*/
+declare enum LyricsAlign {
+    /** Left align lyrics text/syllable. */
+    Left = "left",
+    /** Center align lyrics text/syllable. */
+    Center = "center",
+    /** Right align lyrics text/syllable. */
+    Right = "right"
+}
+/** Lyrics hyphen.*/
+declare enum LyricsHyphen {
+    /** Hyphen. */
+    Hyphen = "-",
+    /** Extender. */
+    Extender = "---"
+}
+/** Lyrics options. */
+type LyricsOptions = {
+    /** Alignment of lyrics text/syllable. */
+    align?: LyricsAlign | `${LyricsAlign}`;
+    /** Hyphen or extender after lyrics text/syllable. */
+    hyphen?: LyricsHyphen | `${LyricsHyphen}`;
+};
+/** Fermata enum. */
+declare enum Fermata {
+    /** Anchor fermata to note/rest. */
+    AtNote = "atNote",
+    /** Anchor fermata to measure end. */
+    AtMeasureEnd = "atMeasureEnd"
+}
+/** Navigation element enum. */
+declare enum Navigation {
+    /** Repeat back to beginning and play to the "Fine" marking. */
+    DC_al_Fine = "D.C. al Fine",
+    /** Repeat back to beginning and play to the "to Coda 𝄌", then jump to the "𝄌 Coda". */
+    DC_al_Coda = "D.C. al Coda",
+    /** Repeat back to Segno sign (𝄋) and play to the "Fine" marking. */
+    DS_al_Fine = "D.S. al Fine",
+    /** Repeat back to Segno sign (𝄋) and play to the "to Coda 𝄌", then jump to the "𝄌 Coda". */
+    DS_al_Coda = "D.S. al Coda",
+    /** "𝄌 Coda" section. */
+    Coda = "Coda",
+    /** From "toCoda 𝄌" jump to the "𝄌 Coda" section. */
+    toCoda = "toCoda",
+    /** Jump here from D.S. al Fine or D.S. al Coda. */
+    Segno = "Segno",
+    /** Stop playing after D.C. al Fine or D.S. al Fine. */
+    Fine = "Fine",
+    /** Start of repeat section. */
+    StartRepeat = "startRepeat",
+    /** End of repeat section. Jump to start of repeat section. */
+    EndRepeat = "endRepeat",
+    /** Jump to ending with correct passage number. */
+    Ending = "ending"
+}
+/** Annotation element enum. */
+declare enum Annotation {
+    /** "ppp", "pp", "p", "mp", "m", "mf", "f", "ff", "fff", "cresc.", "decresc.", "dim." */
+    Dynamics = "dynamics",
+    /** "accel.", "rit.", "a tempo" */
+    Tempo = "tempo"
+}
+/** Some known dynamics annotations. */
+declare enum DynamicsAnnotation {
+    cresc = "cresc.",
+    decresc = "decresc.",
+    dim = "dim.",
+    ppp = "ppp",
+    pp = "pp",
+    p = "p",
+    mp = "mp",
+    m = "m",
+    mf = "mf",
+    f = "f",
+    ff = "ff",
+    fff = "fff"
+}
+/** Some known tempo annotations. */
+declare enum TempoAnnotation {
+    accel = "accel.",
+    rit = "rit.",
+    a_tempo = "a tempo"
+}
+/** Known annotation test type. */
+type AnnotationText = `${DynamicsAnnotation}` | `${TempoAnnotation}`;
+/** Label element enum. */
+declare enum Label {
+    /** "C", "C#", "Db", "D", etc. */
+    Note = "note",
+    /** "C", "Am", "G7", etc. */
+    Chord = "chord"
+}
+/** Play state enum. */
+declare enum PlayState {
+    /** Playing. */
+    Playing = 0,
+    /** Paused. */
+    Paused = 1,
+    /** Stopped. */
+    Stopped = 2
+}
+/** Play state change listener type. */
+type PlayStateChangeListener = (playState: PlayState) => void;
+
+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: number | TieType | `${TieType}`;
+    noteAnchor: NoteAnchor;
+    noteGroups: ObjNoteGroup[];
+    arcDir: "up" | "down";
+    constructor(connective: Connective, span: number | TieType | `${TieType}`, 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(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): 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;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ObjScoreRowGroup extends MusicObject {
+    readonly lines: readonly ObjNotationLine[];
+    private space;
+    readonly instrument: string;
+    readonly hasBrace: boolean;
+    private readonly instrText;
+    private braceRect;
+    readonly mi: MScoreRowGroup;
+    constructor(lines: readonly ObjNotationLine[]);
+    getMusicInterface(): MScoreRowGroup;
+    get row(): ObjScoreRow;
+    get hasInstrument(): boolean;
+    hasNotationLine(line: ObjNotationLine): boolean;
+    pick(x: number, y: number): MusicObject[];
+    updateRect(): void;
+    layout(ctx: RenderContext): void;
+    layoutToNotationLines(): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+type NotationLineObject = {
+    getRect: () => AnchoredRect;
+    offset?: (dx: number, dy: number) => void;
+    offsetInPlace?: (dx: number, dy: number) => void;
+};
+declare abstract class ObjNotationLine extends MusicObject {
+    readonly row: ObjScoreRow;
+    protected readonly objects: NotationLineObject[];
+    abstract readonly id: number;
+    abstract readonly name: string;
+    private layoutGroups;
+    constructor(row: ObjScoreRow);
+    getRowGroup(): ObjScoreRowGroup;
+    addObject(o: NotationLineObject): void;
+    removeObjects(): void;
+    getLayoutGroup(lauoutGroupId: LayoutGroupId): LayoutGroup;
+    resetLayoutGroups(ctx: RenderContext): void;
+    layoutLayoutGroups(ctx: RenderContext): void;
+    private setObjectY;
+    private alignObjectsY;
+    layoutLayoutGroup(ctx: RenderContext, layoutGroup: LayoutGroup, verticalPos: VerticalPos): void;
+    drawVerticalLine(ctx: RenderContext, left: number, width: number, isSystemBarLine?: boolean): void;
+    abstract getConfig(): StaffConfig | TabConfig;
+    abstract calcTop(): number;
+    abstract calcBottom(): number;
+    abstract getTopLineY(): number;
+    abstract getBottomLineY(): number;
+    abstract containsVoiceId(voiceId: number): boolean;
+    abstract containsDiatonicId(diatonicId: number): boolean;
+    abstract layoutWidth(ctx: RenderContext): void;
+    abstract layoutHeight(ctx: RenderContext): void;
+    abstract offset(dx: number, dy: number): void;
+    abstract draw(ctx: RenderContext): void;
+}
+declare class ObjStaff extends ObjNotationLine {
+    readonly staffConfig: StaffConfig;
+    readonly id: number;
+    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;
+    readonly mi: MStaff;
+    constructor(row: ObjScoreRow, staffConfig: StaffConfig, id: number);
+    getMusicInterface(): MStaff;
+    get isOctaveDown(): boolean;
+    get name(): string;
+    getConfig(): StaffConfig | TabConfig;
+    getTopLineY(): number;
+    getMiddleLineY(): number;
+    getBottomLineY(): number;
+    joinGrandStaff(staff: ObjStaff): void;
+    isGrandTreble(): boolean;
+    isGrandBass(): boolean;
+    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: VoiceId): boolean;
+    calcTop(): number;
+    calcBottom(): number;
+    pick(x: number, y: number): MusicObject[];
+    layoutHeight(ctx: RenderContext): void;
+    layoutWidth(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+declare class ObjTab extends ObjNotationLine {
+    readonly tabConfig: TabConfig;
+    readonly id: number;
+    private top;
+    private bottom;
+    private readonly tuningName?;
+    private readonly tuningStrings;
+    readonly mi: MTab;
+    constructor(row: ObjScoreRow, tabConfig: TabConfig, id: number);
+    getMusicInterface(): MTab;
+    get name(): string;
+    getConfig(): StaffConfig | TabConfig;
+    getTuningName(): string | undefined;
+    getTuningStrings(): ReadonlyArray<Note>;
+    /** Return Y coordinate of string. */
+    getStringY(stringId: number): number;
+    getTopStringY(): number;
+    getBottomStringY(): number;
+    getTopLineY(): number;
+    getBottomLineY(): number;
+    getTop(): number;
+    getBottom(): number;
+    containsVoiceId(voiceId: VoiceId): boolean;
+    containsDiatonicId(diatonicId: number): boolean;
+    calcTop(): number;
+    calcBottom(): number;
+    pick(x: number, y: number): MusicObject[];
+    layoutHeight(ctx: RenderContext): void;
+    layoutWidth(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ObjStaffNoteGroup extends MusicObject {
+    readonly staff: ObjStaff;
+    readonly noteGroup: ObjNoteGroup;
+    noteHeadRects: AnchoredRect[];
+    dotRects: AnchoredRect[];
+    accidentals: ObjAccidental[];
+    stemTip?: AnchoredRect;
+    stemBase?: AnchoredRect;
+    flagRects: AnchoredRect[];
+    private prevTopNoteY;
+    private prevBottomNoteY;
+    readonly mi: MStaffNoteGroup;
+    constructor(staff: ObjStaff, noteGroup: ObjNoteGroup);
+    getMusicInterface(): MusicInterface;
+    pick(x: number, y: number): MusicObject[];
+    updateRect(): void;
+    getRect(): AnchoredRect;
+    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: VoiceId;
+    readonly notes: ReadonlyArray<Note>;
+    readonly options?: NoteOptions | undefined;
+    readonly setDiatonicId: number;
+    readonly setStringsNumbers?: StringNumber[];
+    private runningDiatonicId;
+    private runningStemDir;
+    private runningStringNumbers;
+    readonly color: string;
+    readonly staccato: boolean;
+    readonly diamond: boolean;
+    readonly arpeggio: Arpeggio | undefined;
+    readonly oldStyleTriplet: boolean;
+    readonly rhythmProps: RhythmProps;
+    private startConnnectives;
+    private runningConnectives;
+    private leftBeamCount;
+    private rightBeamCount;
+    private beamGroup?;
+    private readonly staffObjects;
+    private readonly tabObjects;
+    private isNoteDisplaced;
+    readonly mi: MNoteGroup;
+    constructor(col: ObjRhythmColumn, voiceId: VoiceId, notes: ReadonlyArray<Note>, noteLength: NoteLength | NoteLengthStr, options?: NoteOptions | undefined, tupletRatio?: TupletRatio);
+    getMusicInterface(): MNoteGroup;
+    get doc(): ObjDocument;
+    get measure(): ObjMeasure;
+    get row(): ObjScoreRow;
+    get minDiatonicId(): number;
+    get maxDiatonicId(): number;
+    getDiatonicId(staff?: ObjStaff): number;
+    get stemDir(): Stem.Up | Stem.Down;
+    setNoteDisplacement(note: Note, isDisplaced: boolean): void;
+    enableConnective(line: ObjNotationLine): boolean;
+    startConnective(connectiveProps: ConnectiveProps): void;
+    updateRunningArguments(diatonicId: number, stemDir: Stem.Up | Stem.Down, stringNumbers: StringNumber[]): void;
+    pick(x: number, y: number): MusicObject[];
+    getTopNote(): Note;
+    getBottomNote(): Note;
+    getConnectiveAnchorPoint(connectiveProps: ConnectiveProps, line: ObjNotationLine, noteIndex: number, noteAnchor: NoteAnchor, side: "left" | "right"): {
+        x: number;
+        y: number;
+    };
+    getFretNumberString(noteIndex: number): StringNumber | undefined;
+    getFretNumber(tab: ObjTab, noteIndex: number): number | undefined;
+    private getNextNoteGroup;
+    collectConnectiveProps(): void;
+    removeConnectiveProps(): void;
+    getPlaySlur(): "first" | "slurred" | undefined;
+    getBeamGroup(): ObjBeamGroup | undefined;
+    setBeamGroup(beamGroup: ObjBeamGroup): void;
+    resetBeamGroup(): void;
+    getBeamCoords(): ({
+        staff: ObjStaff;
+        x: number;
+        y: number;
+        stemHeight: number;
+    } | undefined)[];
+    getStemHeight(ctx: RenderContext): number;
+    hasBeamCount(): boolean;
+    getLeftBeamCount(): number;
+    getRightBeamCount(): number;
+    setLeftBeamCount(count: number): void;
+    setRightBeamCount(count: number): void;
+    hasTuplet(): boolean;
+    isEmpty(): boolean;
+    visibleInStaff(staff: ObjStaff): boolean;
+    getPlayTicks(note: Note): number;
+    updateAccidentalState(accState: AccidentalState): void;
+    layout(ctx: RenderContext, accState: AccidentalState): void;
+    updateRect(): void;
+    setStemTipY(staff: ObjStaff, stemTipY: number): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+    getDotVerticalDisplacement(staff: ObjStaff, diatonicId: number, stemDir: Stem): 1 | 0 | -1;
+    static hasSameNotes(ng1: ObjNoteGroup, ng2: ObjNoteGroup): boolean;
+}
+
+declare enum BeamGroupType {
+    RegularBeam = 0,
+    TupletBeam = 1,
+    TupletGroup = 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(): AnchoredRect;
+}
+declare class ObjStaffBeamGroup extends MusicObject {
+    readonly staff: ObjStaff;
+    readonly beamGroup: ObjBeamGroup;
+    tupletNumber?: ObjText;
+    tupletNumberOffsetY: 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 tupletRatio: TupletRatio & TupletOptions | undefined;
+    readonly mi: MBeamGroup;
+    private readonly type;
+    private readonly staffObjects;
+    private constructor();
+    get stemDir(): Stem.Up | Stem.Down;
+    private get showTupletRatio();
+    static createBeam(noteGroups: ObjNoteGroup[]): boolean;
+    static createOldStyleTriplet(symbols: RhythmSymbol[]): number;
+    static createTuplet(symbols: RhythmSymbol[], tupletRatio: TupletRatio & TupletOptions): void;
+    getMusicInterface(): MBeamGroup;
+    detach(): void;
+    isEmpty(): boolean;
+    pick(x: number, y: number): MusicObject[];
+    getType(): BeamGroupType;
+    isTuplet(): boolean;
+    getTupletRatioText(): string;
+    getSymbols(): ReadonlyArray<RhythmSymbol>;
+    getFirstSymbol(): RhythmSymbol | undefined;
+    getLastSymbol(): RhythmSymbol | undefined;
+    private get color();
+    layout(ctx: RenderContext): void;
+    updateRect(): void;
+    updateStemTips(): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+    private setBeamCounts;
+    private setTupletBeamCounts;
+}
+
+declare class ObjStaffRest extends MusicObject {
+    readonly staff: ObjStaff;
+    readonly rest: ObjRest;
+    restRect: AnchoredRect;
+    dotRects: AnchoredRect[];
+    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: VoiceId;
+    readonly options?: RestOptions | undefined;
+    readonly color: string;
+    readonly hide: boolean;
+    readonly oldStyleTriplet: boolean;
+    readonly rhythmProps: RhythmProps;
+    static UndefinedDiatonicId: number;
+    readonly setDiatonicId: number;
+    private runningDiatonicId;
+    private runningStemDir;
+    private beamGroup?;
+    readonly staffObjects: ObjStaffRest[];
+    readonly mi: MRest;
+    constructor(col: ObjRhythmColumn, voiceId: VoiceId, noteLength: NoteLength | NoteLengthStr, options?: RestOptions | undefined, tupletRatio?: TupletRatio);
+    getMusicInterface(): MRest;
+    get doc(): ObjDocument;
+    get measure(): ObjMeasure;
+    get row(): ObjScoreRow;
+    get noteLength(): NoteLength;
+    getDiatonicId(staff?: ObjStaff): number;
+    get stemDir(): Stem.Up | Stem.Down;
+    updateRunningArguments(diatonicId: number, stemDir: Stem.Up | Stem.Down, stringNumbers: StringNumber[]): void;
+    getStaticObjects(line: ObjNotationLine): ReadonlyArray<MusicObject>;
+    pick(x: number, y: number): MusicObject[];
+    getBeamGroup(): ObjBeamGroup | undefined;
+    setBeamGroup(beamGroup: ObjBeamGroup): void;
+    resetBeamGroup(): void;
+    getBeamCoords(): ({
+        staff: ObjStaff;
+        x: number;
+        y: number;
+        stemHeight: number;
+    } | undefined)[];
+    hasTuplet(): boolean;
+    isEmpty(): boolean;
+    visibleInStaff(staff: ObjStaff): boolean;
+    private getRestDotVerticalDisplacement;
+    updateAccidentalState(accState: AccidentalState): void;
+    layout(ctx: RenderContext, accState: AccidentalState): void;
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ObjLyrics extends MusicObject {
+    readonly col: ObjRhythmColumn;
+    readonly verse: VerseNumber;
+    readonly line: ObjNotationLine;
+    readonly vpos: VerticalPos;
+    private nextLyricsObject?;
+    readonly rhythmProps: RhythmProps;
+    private readonly color;
+    private readonly hyphen?;
+    private readonly text;
+    readonly mi: MLyrics;
+    constructor(col: ObjRhythmColumn, verse: VerseNumber, line: ObjNotationLine, vpos: VerticalPos, lyricsLength: NoteLength, lyricsText: string, lyricsOptions?: LyricsOptions);
+    getMusicInterface(): MLyrics;
+    get measure(): ObjMeasure;
+    getText(): string;
+    setNextLyricsObject(lyricsObj: ObjLyrics): void;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): 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 readonly lyricsObject;
+    private minDiatonicId?;
+    private maxDiatonicId?;
+    private staffMinDiatonicId;
+    private staffMaxDiatonicId;
+    private arpeggioDir;
+    private arpeggios;
+    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(): AnchoredRect[];
+    get doc(): ObjDocument;
+    get row(): ObjScoreRow;
+    pick(x: number, y: number): MusicObject[];
+    hasArpeggio(): boolean;
+    getArpeggioDir(): Arpeggio;
+    setVoiceSymbol(voiceId: VoiceId, symbol: RhythmSymbol): void;
+    getVoiceSymbol(voiceId: VoiceId): RhythmSymbol | undefined;
+    getLyricsObject(verse: VerseNumber, line: ObjNotationLine, vpos: VerticalPos): ObjLyrics | undefined;
+    addLyricsObject(lyricsObj: ObjLyrics): void;
+    updateNoteDisplacements(): void;
+    isEmpty(): boolean;
+    getPlayerNotes(): ScorePlayerNote[];
+    requestLayout(): void;
+    layout(ctx: RenderContext, accState: AccidentalState): void;
+    layoutReserveSpace(ctx: RenderContext): void;
+    layoutDone(): void;
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): 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 ObjStaffBarLine extends MusicObject {
+    readonly barLine: ObjBarLine;
+    readonly line: ObjNotationLine;
+    readonly rowGroup: ObjScoreRowGroup;
+    vlines: {
+        left: number;
+        width: number;
+    }[];
+    dots: {
+        x: number;
+        y: number;
+        r: number;
+    }[];
+    readonly mi: MStaffBarLine;
+    constructor(barLine: ObjBarLine, line: ObjNotationLine, rowGroup: ObjScoreRowGroup);
+    getMusicInterface(): MusicInterface;
+    pick(x: number, y: number): MusicObject[];
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+}
+declare abstract class ObjBarLine extends MusicObject {
+    readonly measure: ObjMeasure;
+    protected notationLineObjects: ObjStaffBarLine[];
+    protected notationLineObjectsByGrp: UniMap<ObjScoreRowGroup, ObjStaffBarLine[]>;
+    protected barLineType: BarLineType;
+    constructor(measure: ObjMeasure);
+    abstract solveBarLineType(): BarLineType;
+    get doc(): ObjDocument;
+    get row(): ObjScoreRow;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): 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 measure: ObjMeasure;
+    private lx;
+    private ly;
+    private rx;
+    private ry;
+    private cp1x;
+    private cp1y;
+    private cp2x;
+    private cp2y;
+    private arcHeight;
+    private readonly line;
+    private readonly leftNoteGroup;
+    private readonly leftNoteId;
+    private readonly rightNoteGroup?;
+    private readonly rightNoteId?;
+    private readonly tieType?;
+    readonly mi: MConnective;
+    constructor(connectiveProps: ConnectiveProps, line: ObjNotationLine, measure: ObjMeasure, leftNoteGroup: ObjNoteGroup, leftNoteId: number, rightNoteGroup: ObjNoteGroup, rightNoteId: number);
+    constructor(connectiveProps: ConnectiveProps, line: ObjNotationLine, measure: ObjMeasure, leftNoteGroup: ObjNoteGroup, leftNoteId: number, tie: TieType);
+    getMusicInterface(): MConnective;
+    get doc(): ObjDocument;
+    isInsideMeasure(): boolean;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ObjSpecialText extends MusicObject {
+    readonly text: string;
+    readonly color: string;
+    static toCoda: string;
+    static Coda: string;
+    static Segno: string;
+    private components;
+    readonly mi: MSpecialText;
+    constructor(parent: MusicObject, text: string, color?: string);
+    getMusicInterface(): MSpecialText;
+    getText(): string;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+type ExtensionStartObject = ObjText | ObjSpecialText;
+type ExtensionLineLeftObject = ObjBarLineLeft | MusicObject;
+type ExtensionLineRightObject = ObjRhythmColumn | ObjBarLineRight;
+type ExtensionStopObject = ObjBarLineRight | ObjText | ObjSpecialText;
+type ExtensionObjectAll = ExtensionStartObject | ExtensionLineLeftObject | ExtensionLineRightObject | ExtensionStopObject;
+declare class ObjExtensionLine extends MusicObject {
+    readonly measure: ObjMeasure;
+    readonly line: ObjNotationLine;
+    readonly extension: Extension;
+    readonly cols: ExtensionObjectAll[];
+    readonly mi: MExtensionLine;
+    constructor(measure: ObjMeasure, line: ObjNotationLine, extension: Extension, cols: ExtensionObjectAll[]);
+    get row(): ObjScoreRow;
+    getMusicInterface(): MExtensionLine;
+    private getLineLeft;
+    private getLineRight;
+    layoutFitToMeasure(ctx: RenderContext): void;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+type ExtensionLineStyle = "solid" | "dashed";
+type ExtensionLinePos = "bottom" | "middle";
+declare class ExtensionRange {
+    readonly startColumn: ObjRhythmColumn;
+    readonly columnRange: ObjRhythmColumn[];
+    stopObject?: ExtensionStopObject;
+    constructor(startColumn: ObjRhythmColumn);
+    get endColumn(): ObjRhythmColumn;
+    addColumn(col: ObjRhythmColumn): void;
+    setStopObject(obj: ExtensionStopObject): void;
+}
+declare class Extension extends MusicObjectLink {
+    readonly headObj: LayoutObjectWrapper;
+    private readonly length;
+    private readonly visible;
+    private readonly lineStyle;
+    private readonly linePos;
+    private readonly startColumn;
+    constructor(headObj: LayoutObjectWrapper, startColumn: ObjRhythmColumn, length: number, visible: boolean, lineStyle: ExtensionLineStyle, linePos: ExtensionLinePos);
+    isVisible(): boolean;
+    getLineStyle(): ExtensionLineStyle;
+    getLinePos(): ExtensionLinePos;
+    private static StopNavigations;
+    private whatStopped;
+    getRange(): ExtensionRange;
+}
+
+declare class ObjMeasure extends MusicObject {
+    readonly row: ObjScoreRow;
+    private readonly options;
+    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 measureId;
+    private regions;
+    private needLayout;
+    private voiceSymbols;
+    private lastAddedRhythmColumn?;
+    private lastAddedRhythmSymbol?;
+    private addExtensionTo;
+    private layoutObjects;
+    private postMeasureBreakWidth;
+    private passCount;
+    private needBeamsUpdate;
+    private navigationSet;
+    private isEndSong;
+    private isEndSection;
+    private endRepeatPlayCount;
+    private endRepeatPlayCountText?;
+    private staticObjectsCache;
+    private lyricsObjectsCache;
+    readonly mi: MMeasure;
+    constructor(row: ObjScoreRow, options: MeasureOptions);
+    getMusicInterface(): MMeasure;
+    get doc(): ObjDocument;
+    isPartialMeasure(): boolean;
+    isUpBeat(): boolean;
+    resetPassCount(): void;
+    incPassCount(): void;
+    getPassCount(): number;
+    updateRunningArguments(runningArgs?: {
+        diatonicId: number;
+        stemDir: Stem;
+        stringNumbers: StringNumber[];
+    }[]): void;
+    pick(x: number, y: number): MusicObject[];
+    getMeasureNumber(): number;
+    getColumns(): ReadonlyArray<ObjRhythmColumn>;
+    getColumnCount(): number;
+    getColumn(columnId: number): ObjRhythmColumn | undefined;
+    isFirstMeasure(): boolean;
+    isLastMeasure(): boolean;
+    isFirstMeasureInRow(): boolean;
+    isLastMeasureInRow(): boolean;
+    getNextMeasure(): ObjMeasure | undefined;
+    getPrevMeasure(): ObjMeasure | undefined;
+    getKeySignature(): KeySignature;
+    setKeySignature(...args: unknown[]): void;
+    updateKeySignature(): void;
+    getTimeSignature(): TimeSignature;
+    setTimeSignature(timeSignature: TimeSignature): void;
+    updateTimeSignature(): void;
+    getTempo(): Tempo;
+    setTempo(beatsPerMinute: number, beatLength?: NoteLength | NoteLengthStr): void;
+    updateTempo(): void;
+    hasPostMeasureBreak(): boolean;
+    getPostMeasureBreakWidth(): number;
+    private addLayoutObject;
+    private forEachStaffGroup;
+    addFermata(staffTabOrGroups: StaffTabOrGroups | undefined, fermata: Fermata): void;
+    hasFermata(anchor: ObjRhythmColumn | ObjBarLineRight): boolean;
+    addNavigation(staffTabOrGroups: StaffTabOrGroups | undefined, navigation: Navigation, ...args: unknown[]): void;
+    hasNavigation(n: Navigation): boolean;
+    addAnnotation(staffTabOrGroups: StaffTabOrGroups | undefined, annotation: Annotation, text: string): void;
+    addLabel(staffTabOrGroups: StaffTabOrGroups | undefined, label: Label, text: string): void;
+    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;
+    addExtension(extensionLength: number | NoteLengthStr | (NoteLengthStr | number)[], extensionVisible: boolean): void;
+    private enableExtension;
+    private disableExtension;
+    getEnding(): ObjEnding | undefined;
+    getEndRepeatPlayCount(): number;
+    endSong(): void;
+    hasEndSong(): boolean;
+    endSection(): void;
+    hasEndSection(): boolean;
+    endRow(): void;
+    private addRhythmSymbol;
+    addNoteGroup(voiceId: VoiceId, notes: (Note | string)[], noteLength: NoteLength | NoteLengthStr, options?: NoteOptions, tupletRatio?: TupletRatio): ObjNoteGroup;
+    addRest(voiceId: VoiceId, restLength: NoteLength | NoteLengthStr, options?: RestOptions, tupletRatio?: TupletRatio): ObjRest;
+    addLyrics(staffTabOrGroups: StaffTabOrGroups | undefined, verse: VerseNumber, lyricsLength: NoteLength | NoteLengthStr, lyricsText: string, lyricsOptions: LyricsOptions): void;
+    /**
+     *
+     * @param positionTicks - get ObjRhythmColumn with positionTicks. Insert new if necessary.
+     * @returns
+     */
+    private getRhythmColumn;
+    getMeasureTicks(): number;
+    getConsumedTicks(voiceId?: VoiceId): number;
+    getColumnsContentRect(): AnchoredRect;
+    getLeftSolidWidth(): number;
+    getMinColumnsWidth(): number;
+    getRightSolidWidth(): number;
+    getTotalSolidWidth(): number;
+    getMinWidth(): number;
+    getStaffLineLeft(): number;
+    getStaffLineRight(): number;
+    getPrevLyricsObject(lyricsObj: ObjLyrics): ObjLyrics | undefined;
+    getStaticObjects(line: ObjNotationLine): ReadonlyArray<MusicObject>;
+    addStaticObject(line: ObjNotationLine, staticObj: MusicObject): void;
+    removeLayoutObjects(musicObj: MusicObject): void;
+    addConnectiveObject(connective: ObjConnective): void;
+    removeConnectiveObjects(): void;
+    createExtensions(): void;
+    addBeamGroup(beam: ObjBeamGroup): void;
+    requestBeamsUpdate(): void;
+    private createOldStyleTriplets;
+    getBeamGroups(): ReadonlyArray<ObjBeamGroup>;
+    createBeams(): void;
+    getBarLineLeft(): ObjBarLineLeft;
+    getBarLineRight(): ObjBarLineRight;
+    getVoiceSymbols(voiceId: VoiceId): ReadonlyArray<RhythmSymbol>;
+    completeRests(voiceId?: VoiceId | VoiceId[]): void;
+    requestLayout(): void;
+    layout(ctx: RenderContext): void;
+    layoutWidth(ctx: RenderContext, width: number): void;
+    layoutConnectives(ctx: RenderContext): void;
+    layoutBeams(ctx: RenderContext): void;
+    alignStemsToBeams(): void;
+    layoutDone(): void;
+    updateRect(): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ScoreRowRegions {
+    instrWidth: number;
+    staffWidth: number;
+    resetWidths(): void;
+    addRowInstrWidth(w: number): void;
+    addRowstaffWidth(w: number): void;
+    get instrLeft(): number;
+    get instrRight(): number;
+    get staffLeft(): number;
+    get staffRight(): number;
+    get left(): number;
+    get right(): number;
+    get width(): number;
+}
+declare class ObjScoreRow extends MusicObject {
+    readonly doc: ObjDocument;
+    private readonly prevRow;
+    private readonly scoreConfig;
+    private nextRow?;
+    private readonly notationLines;
+    private readonly rowGroups;
+    private readonly staves;
+    private readonly tabs;
+    private readonly measures;
+    private rowGroupByLine;
+    private needLayout;
+    readonly mi: MScoreRow;
+    constructor(doc: ObjDocument, prevRow: ObjScoreRow | undefined, scoreConfig: (StaffConfig | TabConfig)[]);
+    getMusicInterface(): MScoreRow;
+    private createNotationLines;
+    getNotationLines(): ReadonlyArray<ObjNotationLine>;
+    getRowGroups(): ReadonlyArray<ObjScoreRowGroup>;
+    getRowGroupByLineId(id: number): ObjScoreRowGroup;
+    findMatchingLine(line: ObjNotationLine): ObjNotationLine | undefined;
+    get regions(): ScoreRowRegions;
+    getStaves(): ReadonlyArray<ObjStaff>;
+    getTabs(): ReadonlyArray<ObjTab>;
+    get hasStaff(): boolean;
+    get hasTab(): boolean;
+    getTopStaff(): ObjStaff;
+    getBottomStaff(): ObjStaff;
+    getStaff(diatonicId: number): ObjStaff | undefined;
+    resetLayoutGroups(ctx: RenderContext): void;
+    layoutLayoutGroups(ctx: RenderContext): void;
+    pick(x: number, y: number): MusicObject[];
+    getConnectivesContentRect(): AnchoredRect;
+    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;
+    solveAutoStemDir(symbols: ReadonlyArray<RhythmSymbol>): Stem.Up | Stem.Down;
+    requestLayout(): void;
+    layout(ctx: RenderContext): void;
+    layoutStretch(ctx: RenderContext): void;
+    updateRect(): void;
+    alignStemsToBeams(): void;
+    layoutSetNotationLines(ctx: RenderContext): void;
+    layoutDone(): void;
+    offset(dx: number, dy: number): void;
+    getStaffLineLeft(): number | undefined;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ObjDocument extends MusicObject {
+    private needLayout;
+    private ctx?;
+    readonly regions: ScoreRowRegions;
+    private readonly rows;
+    private readonly measures;
+    private measuresPerRow;
+    private curScoreConfig;
+    private header?;
+    private newRowRequested;
+    private allConnectiveProps;
+    private staffGroups;
+    private readonly mi;
+    constructor();
+    getMusicInterface(): MDocument;
+    setScoreConfiguration(config: StaffPreset | ScoreConfiguration): void;
+    setMeasuresPerRow(measuresPerRow: number): void;
+    addConnectiveProps(connectiveProps: ConnectiveProps): void;
+    setRenderContext(ctx?: RenderContext): 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;
+    getRows(): ReadonlyArray<ObjScoreRow>;
+    getMeasures(): ReadonlyArray<ObjMeasure>;
+    requestNewRow(): void;
+    addMeasure(measureOptions: MeasureOptions): ObjMeasure;
+    addStaffGroup(groupName: string, layoutElements: number | string | (number | string)[], verticalPosition: VerticalPosition): void;
+    getStaffGroup(groupName: string): StaffGroup | undefined;
+    getVoiceSymbols(voiceId: VoiceId): ReadonlyArray<RhythmSymbol>;
+    removeLayoutObjects(musicObj: MusicObject): void;
+    private forEachMeasure;
+    resetMeasures(): void;
+    updateCursorRect(cursorRect?: Rect): void;
+    requestLayout(): void;
+    requestFullLayout(): void;
+    layout(): void;
+    offset(dx: number, dy: number): void;
+    drawContent(): void;
+    pickStaffPosAt(x: number, y: number): {
+        scoreRow: ObjScoreRow;
+        diatonicId: number;
+    } | undefined;
+    pick(x: number, y: number): MusicObject[];
+}
+
+declare enum ImageAsset {
+    G_Clef = 0,
+    F_Clef = 1
+}
+declare class RenderContext {
+    private readonly mi;
+    readonly devicePixelRatio: number;
+    readonly fontSize: number;
+    readonly unitSize: number;
+    readonly _lineWidth: 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: MRenderContext);
+    getMusicInterface(): MRenderContext;
+    get doc(): ObjDocument | undefined;
+    getImageAsset(asset: ImageAsset, color?: string): HTMLImageElement | undefined;
+    private forceDraw;
+    private onImageLoaded;
+    setDocument(mdoc?: MDocument): void;
+    setCanvas(canvas: HTMLCanvasElement): void;
+    setScoreEventListener(fn: ScoreEventListener): void;
+    needMouseInput(): boolean;
+    getMousePos(e: MouseEvent): Vec;
+    private updateCurStaffPos;
+    private updateCurObjects;
+    onClick(e: MouseEvent): void;
+    onMouseMove(e: MouseEvent): void;
+    onMouseLeave(e: MouseEvent): void;
+    onTouchEnd(e: TouchEvent): void;
+    hilightObject(obj?: MusicObject): void;
+    hilightStaffPos(staffPos?: {
+        scoreRow: ObjScoreRow;
+        diatonicId: number;
+    }): void;
+    updateCursorRect(cursorRect: Rect | undefined): void;
+    updateCanvasSize(): void;
+    draw(): void;
+    drawHilightStaffPosRect(): void;
+    drawHilightObjectRect(): void;
+    drawPlayCursor(): void;
+    txFromScreenCoord(screenCoord: Vec): Vec;
+    txToScreenCoord(coord: Vec): Vec;
+    clearCanvas(): void;
+    drawDebugRect(r: AnchoredRect | Rect): void;
+    drawLedgerLines(staff: ObjStaff, diatonicId: number, x: number): void;
+    getRestRect(restSize: number): AnchoredRect;
+    drawRest(restSize: number, x: number, y: number): void;
+    drawFlag(rect: Rect | AnchoredRect, dir: "up" | "down"): void;
+    color(color: string): RenderContext;
+    lineColor(color: string): RenderContext;
+    fillColor(color: string): RenderContext;
+    lineWidth(lineWidth?: number): RenderContext;
+    font(font: string): RenderContext;
+    beginPath(): RenderContext;
+    stroke(): RenderContext;
+    fill(): RenderContext;
+    moveTo(x: number, y: number): RenderContext;
+    lineTo(x: number, y: number): RenderContext;
+    bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): RenderContext;
+    quadraticCurveTo(x1: number, y1: number, x2: number, y2: number): RenderContext;
+    fillRect(x: number, y: number, w: number, h: number): RenderContext;
+    setLineDash(pattern: number[]): RenderContext;
+    drawImage(img: CanvasImageSource, x: number, y: number, w: number, h: number): RenderContext;
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number): RenderContext;
+    clip(): RenderContext;
+    save(): RenderContext;
+    restore(): RenderContext;
+    rect(x: number, y: number, w: number, h: number): RenderContext;
+    scale(x: number, y: number): RenderContext;
+    strokeRect(x: number, y: number, w: number, h: number): RenderContext;
+    fillText(text: string, x: number, y: number): RenderContext;
+    getTextWidth(text: string, font: string): number;
+    arc(x: number, y: number, radius: number, startRadians: number, endRadians: number): RenderContext;
+    fillCircle(x: number, y: number, radius: number): RenderContext;
+    strokeLine(startX: number, startY: number, endX: number, endY: number): RenderContext;
+    strokePartialLine(startX: number, startY: number, endX: number, endY: number, startT: number, endT: number): RenderContext;
+    drawBracket(rect: AnchoredRect, bracket: "(" | ")" | "[" | "]" | "{" | "}" | "<" | ">"): RenderContext;
+}
+
+declare class ObjEnding extends MusicObject {
+    readonly measure: ObjMeasure;
+    readonly color: string;
+    readonly passages: number[];
+    private endingText;
+    private shapeRects;
+    readonly mi: MEnding;
+    constructor(measure: ObjMeasure, color: string, passages: number[]);
+    getMusicInterface(): MEnding;
+    getShapeRects(): AnchoredRect[];
+    isSingleMeasureEnding(): boolean;
+    hasPassage(pass: number): boolean;
+    getHighestPassage(): number;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    layoutFitToMeasure(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ObjFermata extends MusicObject {
+    readonly pos: VerticalPos;
+    readonly color: string;
+    readonly mi: MFermata;
+    constructor(parent: ObjRhythmColumn | ObjBarLineRight, pos: VerticalPos, color: string);
+    getMusicInterface(): MFermata;
+    static getFermataPositions(anchor: ObjRhythmColumn | ObjBarLineRight): VerticalPos[];
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ObjTabRhythm extends MusicObject {
+    readonly measure: ObjMeasure;
+    readonly tab: ObjTab;
+    private readonly voiceId;
+    readonly mi: MTabRhythm;
+    constructor(measure: ObjMeasure, tab: ObjTab);
+    getMusicInterface(): MTabRhythm;
+    get doc(): ObjDocument;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    private hasTuplets;
+    layoutFitToMeasure(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    private readonly tupletPartsTextObjMap;
+    draw(ctx: RenderContext): void;
+}
+
+declare enum LayoutGroupId {
+    TabRhythm = 0,
+    Fermata = 1,
+    NoteLabel = 2,
+    Navigation = 3,
+    Ending = 4,
+    TempoAnnotation = 5,
+    DynamicsAnnotation = 6,
+    ChordLabel = 7,
+    LyricsVerse1 = 8,
+    LyricsVerse2 = 9,
+    LyricsVerse3 = 10
+}
+declare enum VerticalPos {
+    Above = 0,
+    Below = 1
+}
+type LayoutableMusicObject = ObjText | ObjSpecialText | ObjExtensionLine | ObjFermata | ObjEnding | ObjLyrics | ObjTabRhythm;
+declare class StaffGroup {
+    readonly groupName: string;
+    readonly staffsTabsAndGroups: number | string | (number | string)[];
+    readonly verticalPosition: VerticalPosition;
+    constructor(groupName: string, staffsTabsAndGroups: number | string | (number | string)[], verticalPosition: VerticalPosition);
+}
+declare class LayoutObjectWrapper {
+    readonly musicObj: LayoutableMusicObject;
+    readonly line: ObjNotationLine;
+    readonly layoutGroupId: LayoutGroupId;
+    readonly verticalPos: VerticalPos;
+    readonly anchor: MusicObject;
+    readonly measure: ObjMeasure;
+    readonly row: ObjScoreRow;
+    readonly layoutGroup: LayoutGroup;
+    private positionResolved;
+    constructor(musicObj: LayoutableMusicObject, line: ObjNotationLine, layoutGroupId: LayoutGroupId, verticalPos: VerticalPos);
+    resetPositionResolved(): void;
+    setPositionResolved(): void;
+    isPositionResolved(): boolean;
+    resolveClosestToStaffY(ctx: RenderContext): number;
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    setAnchorY(y: number): void;
+    getRect(): AnchoredRect;
+}
+declare class LayoutGroup {
+    readonly layoutGroupId: number;
+    private readonly layoutObject;
+    readonly rowAlign: boolean;
+    readonly reserveSpace: boolean;
+    readonly padding: number;
+    constructor(layoutGroupId: number);
+    getLayoutObjects(verticalPos: VerticalPos): Readonly<LayoutObjectWrapper[]>;
+    add(layoutObj: LayoutObjectWrapper): void;
+    remove(layoutObj: LayoutObjectWrapper): void;
+    layout(ctx: RenderContext): void;
+    getPadding(ctx: RenderContext): number;
+}
+
+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?;
+    readonly userData: Record<string, unknown>;
+    constructor(parent: MusicObject | undefined);
+    abstract getMusicInterface(): MusicInterface;
+    getParent(): MusicObject | undefined;
+    protected rect: AnchoredRect;
+    private needRectUpdate;
+    requestRectUpdate(): void;
+    updateRect(): void;
+    forceRectUpdate(): void;
+    getRect(): AnchoredRect;
+    abstract offset(dx: number, dy: number): void;
+    offsetX(dx: number): void;
+    offsetY(dy: number): void;
+    setLeft(x: number): void;
+    setRight(x: number): void;
+    setTop(y: number): void;
+    setBottom(y: number): void;
+    setAnchor(x: number, y: number): void;
+    setAnchorX(x: number): void;
+    setAnchorY(y: number): void;
+    setCenter(x: number, y: number): void;
+    setCenterX(x: number): void;
+    setCenterY(y: number): void;
+    /**
+     * 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(): AnchoredRect[];
+    /**
+     * 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 line: ObjNotationLine;
+    readonly arpeggioDir: Arpeggio;
+    private topArrowHeight;
+    private bottomArrowHeight;
+    private cycleHeight;
+    private numCycles;
+    private color;
+    readonly mi: MArpeggio;
+    constructor(col: ObjRhythmColumn, line: ObjNotationLine, arpeggioDir: Arpeggio);
+    getMusicInterface(): MArpeggio;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ObjHeader extends MusicObject {
+    readonly doc: ObjDocument;
+    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[];
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): 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(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+declare class ObjStaffSignature 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: MStaffSignature;
+    constructor(measure: ObjMeasure, staff: ObjStaff);
+    get doc(): ObjDocument;
+    getMusicInterface(): MStaffSignature;
+    updateClefImage(ctx: RenderContext, 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(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+declare class ObjTabSignature extends MusicObject {
+    readonly measure: ObjMeasure;
+    readonly tab: ObjTab;
+    private measureNumber?;
+    private beatCountText?;
+    private beatSizeText?;
+    private tempoText?;
+    readonly mi: MTabSignature;
+    constructor(measure: ObjMeasure, tab: ObjTab);
+    getMusicInterface(): MTabSignature;
+    get doc(): ObjDocument;
+    updateMeasureNumber(showMeasureNumber: boolean): void;
+    updateTimeSignature(showTimeSignature: boolean): void;
+    updateTempo(showTempo: boolean): void;
+    pick(x: number, y: number): MusicObject[];
+    layout(ctx: RenderContext): void;
+    offset(dx: number, dy: number): void;
+    draw(ctx: RenderContext): void;
+}
+
+/** Score event type. */
+type ScoreEventType = "enter" | "leave" | "click";
+/** Abstract score event class. */
+declare abstract class ScoreEvent {
+    readonly type: ScoreEventType;
+    /**
+     * Create new score event instance.
+     * @param type - Score event type.
+     */
+    constructor(type: ScoreEventType);
+}
+/** Score staff position event for clicking/entering/leaving staff position (diatonic id) in staff notation line. */
+declare class ScoreStaffPosEvent extends ScoreEvent {
+    readonly renderContext: MRenderContext;
+    readonly scoreRow: MScoreRow;
+    readonly diatonicId: number;
+    /**
+     * Create new score staff position event.
+     * @param type - Score event type.
+     * @param renderContext - Render context.
+     * @param scoreRow - Score row.
+     * @param diatonicId - Diatonic id that was clicked/entered/left.
+     */
+    constructor(type: ScoreEventType, renderContext: MRenderContext, scoreRow: MScoreRow, diatonicId: number);
+}
+/** Score object event for clicking/entering/leaving score object. */
+declare class ScoreObjectEvent extends ScoreEvent {
+    readonly renderContext: MRenderContext;
+    readonly objects: MusicInterface[];
+    /**
+     * Create new score object event.
+     * @param type - Score event type.
+     * @param renderContext - Render context.
+     * @param objects - Array of objects, last object in this array is the top object that was clicked/entered/left, previous objects are it's parent objects.
+     */
+    constructor(type: ScoreEventType, renderContext: MRenderContext, objects: MusicInterface[]);
+    /** Top object getter. */
+    get topObject(): MusicInterface;
+    /**
+     * Find object.
+     * @param fn - Compare function.
+     * @returns - First object that matched compare function, or undefined if no match.
+     */
+    findObject(fn: (obj: MusicInterface) => boolean): MusicInterface | undefined;
+}
+/** Score event listener type. */
+type ScoreEventListener = (event: ScoreEvent) => void;
+
+/** Music player class. */
+declare class MPlayer {
+    private static currentlyPlaying;
+    private readonly player;
+    /**
+     * Create new music player.
+     * @param doc - Music document to play.
+     * @param playStateChangeListener - Play state change listener.
+     */
+    constructor(doc: MDocument, playStateChangeListener?: PlayStateChangeListener);
+    /**
+     * Stop all playing.
+     */
+    static stopAll(): void;
+    /**
+     * Playe attached document.
+     * @returns - This player instance.
+     */
+    play(): this;
+    /**
+     * Pause playback of attached document.
+     * @returns - This player instance.
+     */
+    pause(): this;
+    /**
+     * Stop playback of attached document.
+     * @returns - This player instance.
+     */
+    stop(): this;
+}
+/** Render context class. */
+declare class MRenderContext {
+    private readonly ctx;
+    /**
+     * Create new render context instance.
+     */
+    constructor();
+    /**
+     * Attach music document to this render context.
+     * @param doc - Music document.
+     * @returns - This render context instance.
+     */
+    setDocument(doc?: MDocument): MRenderContext;
+    /**
+     * Set target canvas html element for this render context.
+     * @param canvas - HTML canvas element or element id.
+     * @returns - This render context instance.
+     */
+    setCanvas(canvas: HTMLCanvasElement | string): MRenderContext;
+    /**
+     * Set score event listener.
+     * @param scoreEventListener - Score event listener.
+     */
+    setScoreEventListener(scoreEventListener: ScoreEventListener): void;
+    /**
+     * Draw given music object hilighted.
+     * @param obj - Music object or undefined to remove hilighting.
+     */
+    hilightObject(obj?: MusicInterface): void;
+    /**
+     * Draw given staff position hilighted.
+     * @param staffPos - Staff position (score row and diatonic id) or undefined to remove hilighting.
+     */
+    hilightStaffPos(staffPos?: {
+        scoreRow: MScoreRow;
+        diatonicId: number;
+    }): void;
+    /**
+     * Draw contents of attached music document to attached canvas.
+     */
+    draw(): void;
+}
+/** Playback buttons helper class. */
+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?;
+    /**
+     * Create new playback buttons helper class instance.
+     */
+    constructor();
+    /**
+     * Attach music document whose playcak will be controlled by this playback buttons helper class instance.
+     * @param doc - Music document.
+     * @returns
+     */
+    setDocument(doc?: MDocument): MPlaybackButtons;
+    /**
+     * Detach attached music document.
+     */
+    detachDocument(): void;
+    private updateButtons;
+    /**
+     * Set play button.
+     * @param btn - HTML button element or element id.
+     * @param btnLabel - Custom button label (e.g. "Play").
+     * @returns - This playback buttons class instance.
+     */
+    setPlayButton(btn: HTMLButtonElement | string, btnLabel?: string): MPlaybackButtons;
+    /**
+     * Set stop button.
+     * @param btn - HTML button element or element id.
+     * @param btnLabel - Custom button label (e.g. "Stop").
+     * @returns - This playback buttons class instance.
+     */
+    setStopButton(btn: HTMLButtonElement | string, btnLabel?: string): MPlaybackButtons;
+    /**
+     * Set play/stop button.
+     * @param btn - HTML button element or element id.
+     * @param playLabel - Custom button label for play action (e.g. "Play").
+     * @param stopLabel - Custom button label for stop action (e.g. "Stop").
+     * @returns - This playback buttons class instance.
+     */
+    setPlayStopButton(btn: HTMLButtonElement | string, playLabel?: string, stopLabel?: string): MPlaybackButtons;
+    /**
+     * Set pause button.
+     * @param btn - HTML button element or element id.
+     * @param btnLabel - Custom button label (e.g. "Pause").
+     * @returns - This playback buttons class instance.
+     */
+    setPauseButton(btn: HTMLButtonElement | string, btnLabel?: string): MPlaybackButtons;
+    private static savedOnClickListeners;
+    private static removeOnClickListeners;
+    private static addOnClickListener;
+}
+
+/** Abstract music interface object class. */
+declare abstract class MusicInterface {
+    readonly name: string;
+    /**
+     * Create new music interface object.
+     * @param name - OBject name.
+     */
+    constructor(name: string);
+    /** @internal */
+    abstract getMusicObject(): MusicObject;
+    /**
+     * Get parent object.
+     * @returns - Parent object or undefined.
+     */
+    getParent(): MusicInterface | undefined;
+}
+/** Accidental object. */
+declare class MAccidental extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Accidental";
+    /** @internal */
+    constructor(obj: ObjAccidental);
+    /** @internal */
+    getMusicObject(): ObjAccidental;
+    /**
+     * Get accidental.
+     * @returns - Accidental (e.g. 1 = #).
+     */
+    getAccidental(): Accidental;
+}
+/** Connective object. */
+declare class MConnective extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Connective";
+    /** @internal */
+    constructor(obj: ObjConnective);
+    /** @internal */
+    getMusicObject(): ObjConnective;
+}
+/** Arpeggio object. */
+declare class MArpeggio extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Arpeggio";
+    /** @internal */
+    constructor(obj: ObjArpeggio);
+    /** @internal */
+    getMusicObject(): ObjArpeggio;
+    /**
+     * Get rhythm column this arpeggio is in.
+     * @returns - Rhythm column.
+     */
+    getRhythmColumn(): MRhythmColumn;
+    /**
+     * Get notation line this arpeggio is in.
+     * @returns - Staff or tab object.
+     */
+    getNotationLine(): MStaff | MTab;
+}
+/** Beam group object. */
+declare class MBeamGroup extends MusicInterface {
+    private readonly obj;
+    /** OBject name. */
+    static readonly Name = "BeamGroup";
+    /** @internal */
+    constructor(obj: ObjBeamGroup);
+    /** @internal */
+    getMusicObject(): ObjBeamGroup;
+}
+/** Beam group object of certain staff. */
+declare class MStaffBeamGroup extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "StaffBeamGroup";
+    /** @internal */
+    constructor(obj: ObjStaffBeamGroup);
+    /** @internal */
+    getMusicObject(): ObjStaffBeamGroup;
+    /**
+     * Get staff this beam group is in.
+     * @returns - Staff object.
+     */
+    getStaff(): MStaff;
+}
+/** Document object. */
+declare class MDocument extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Document";
+    /** @internal */
+    constructor(obj: ObjDocument);
+    /** @internal */
+    getMusicObject(): ObjDocument;
+    /**
+     * Get title.
+     * @returns - Title string or undefined.
+     */
+    getTitle(): string | undefined;
+    /**
+     * Get composer.
+     * @returns - Composer string or undefined.
+     */
+    getComposer(): string | undefined;
+    /**
+     * Get arranger.
+     * @returns - Arranger string or undefined.
+     */
+    getArranger(): string | undefined;
+    /**
+     * Get score rows.
+     * @returns - Array or score rows.
+     */
+    getRows(): ReadonlyArray<MScoreRow>;
+    /**
+     * Get measures.
+     * @returns - Array of measures.
+     */
+    getMeasures(): ReadonlyArray<MMeasure>;
+    /**
+     * Play this document.
+     * @param playStateChangeListener - Play state change listener function or undefined.
+     * @returns - Player instance.
+     */
+    play(playStateChangeListener?: PlayStateChangeListener): MPlayer;
+}
+/** Ending object. */
+declare class MEnding extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Ending";
+    /** @internal */
+    constructor(obj: ObjEnding);
+    /** @internal */
+    getMusicObject(): ObjEnding;
+    /**
+     * Get passages.
+     * @returns - Array of passage numbers, e.g. passage number 1 means that this ending is played on first pass.
+     */
+    getPassages(): ReadonlyArray<number>;
+    /**
+     * Has passage number?
+     * @param passage - Passage number to find out.
+     * @returns - Boolean whether this ending has asked passage number.
+     */
+    hasPassage(passage: number): boolean;
+}
+/** Fermata object. */
+declare class MFermata extends MusicInterface {
+    private readonly obj;
+    /** OBject name. */
+    static readonly Name = "Fermata";
+    /** @internal */
+    constructor(obj: ObjFermata);
+    /** @internal */
+    getMusicObject(): ObjFermata;
+}
+/** Header object. */
+declare class MHeader extends MusicInterface {
+    private readonly obj;
+    /** OBject name. */
+    static readonly Name = "Header";
+    /** @internal */
+    constructor(obj: ObjHeader);
+    /** @internal */
+    getMusicObject(): ObjHeader;
+    /**
+     * Get title.
+     * @returns - Title string or undefined.
+     */
+    getTitle(): string | undefined;
+    /**
+     * Get composer.
+     * @returns - Composer string or undefined.
+     */
+    getComposer(): string | undefined;
+    /**
+     * Get arranger.
+     * @returns - Arranger string or undefined.
+     */
+    getArranger(): string | undefined;
+}
+/** Image object. */
+declare class MImage extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Image";
+    /** @internal */
+    constructor(obj: ObjImage);
+    /** @internal */
+    getMusicObject(): ObjImage;
+}
+/** Measure object. */
+declare class MMeasure extends MusicInterface {
+    private readonly obj;
+    /** OBject name. */
+    static readonly Name = "Measure";
+    /** @internal */
+    constructor(obj: ObjMeasure);
+    /** @internal */
+    getMusicObject(): ObjMeasure;
+    /**
+     * Get measure number.
+     * @returns - Measure number starting from 1, or 0 if upbeat.
+     */
+    getMeasureNumber(): number;
+    /**
+     * Get rhythm columns.
+     * @returns - Array of rhythm columns.
+     */
+    getRhythmColumns(): ReadonlyArray<MRhythmColumn>;
+    /**
+     * Get score row that this measure is in.
+     * @returns - Score row.
+     */
+    getRow(): MScoreRow;
+}
+/** Right bar line object. */
+declare class MBarLineRight extends MusicInterface {
+    private readonly obj;
+    /** OBject name. */
+    static readonly Name = "BarLineRight";
+    /** @internal */
+    constructor(obj: ObjBarLineRight);
+    /** @internal */
+    getMusicObject(): ObjBarLineRight;
+}
+/** Left bar line object. */
+declare class MBarLineLeft extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "BarLineLeft";
+    /** @internal */
+    constructor(obj: ObjBarLineLeft);
+    /** @internal */
+    getMusicObject(): ObjBarLineLeft;
+}
+/** Bar line object for certain staff or tab. */
+declare class MStaffBarLine extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "StaffBarLine";
+    /** @internal */
+    constructor(obj: ObjStaffBarLine);
+    /** @internal */
+    getMusicObject(): ObjStaffBarLine;
+    /**
+     * Get parent bar line object.
+     * @returns - Parent bar line object.
+     */
+    getBarLine(): MBarLineLeft | MBarLineRight;
+    /**
+     * Get staff or tab this bar lien object is in.
+     * @returns - Staff or tab.
+     */
+    getNotationLine(): MStaff | MTab;
+}
+/** Note group object. */
+declare class MNoteGroup extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "NoteGroup";
+    /** @internal */
+    constructor(obj: ObjNoteGroup);
+    /** @internal */
+    getMusicObject(): ObjNoteGroup;
+    /**
+     * Get notes of this note group.
+     * @returns - Array of Note instances.
+     */
+    getNotes(): ReadonlyArray<Note>;
+    /**
+     * Get rhythm props of this note group.
+     * @returns - Rhythm props.
+     */
+    getRhythmProps(): RhythmProps;
+    /**
+     * Get rhythm column this note group is in.
+     * @returns - Rhythm column.
+     */
+    getRhythmColumn(): MRhythmColumn;
+    /**
+     * Get the measure this note group is in.
+     * @returns - Measure.
+     */
+    getMeasure(): MMeasure;
+}
+/** Note group object of certain staff. */
+declare class MStaffNoteGroup extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "StaffNoteGroup";
+    /** @internal */
+    constructor(obj: ObjStaffNoteGroup);
+    /** @internal */
+    getMusicObject(): ObjStaffNoteGroup;
+    /**
+     * Get parent note group.
+     * @returns - Parent note group.
+     */
+    getNoteGroup(): MNoteGroup;
+    /**
+     * Get rhythm column this note group is in.
+     * @returns - Rhythm column.
+     */
+    getRhythmColumn(): MRhythmColumn;
+    /**
+     * Get the measure this note group is in.
+     * @returns - Measure.
+     */
+    getMeasure(): MMeasure;
+    /**
+     * Get staff notation line this note group is in.
+     * @returns - Staff object.
+     */
+    getStaff(): MStaff;
+}
+/** Note group object of certain tab. Contains fret numbers for tab. */
+declare class MTabNoteGroup extends MusicInterface {
+    private readonly obj;
+    /** OBject name. */
+    static readonly Name = "TabNoteGroup";
+    /** @internal */
+    constructor(obj: ObjTabNoteGroup);
+    /** @internal */
+    getMusicObject(): ObjTabNoteGroup;
+    /**
+     * Get parent note group.
+     * @returns - Parent note group.
+     */
+    getNoteGroup(): MNoteGroup;
+    /**
+     * Get rhythm column this note group is in.
+     * @returns - Rhythm column.
+     */
+    getRhythmColumn(): MRhythmColumn;
+    /**
+     * Get the measure this note group is in.
+     * @returns - Measure.
+     */
+    getMeasure(): MMeasure;
+    /**
+     * Get guitar tab this note group is in.
+     * @returns - Tab object.
+     */
+    getTab(): MTab;
+}
+/** Rest object. */
+declare class MRest extends MusicInterface {
+    private readonly obj;
+    /** OBject name. */
+    static readonly Name = "Rest";
+    /** @internal */
+    constructor(obj: ObjRest);
+    /** @internal */
+    getMusicObject(): ObjRest;
+    /**
+     * Get rhythm props of this rest.
+     * @returns - Rhythm props.
+     */
+    getRhythmProps(): RhythmProps;
+    /**
+     * Get rhythm column this rest is in.
+     * @returns - Rhythm column.
+     */
+    getRhythmColumn(): MRhythmColumn;
+    /**
+     * Get the measure this rest is in.
+     * @returns - Measure.
+     */
+    getMeasure(): MMeasure;
+}
+/** Rest object for certain tab. */
+declare class MStaffRest extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "StaffRest";
+    /** @internal */
+    constructor(obj: ObjStaffRest);
+    /** @internal */
+    getMusicObject(): ObjStaffRest;
+    /**
+     * Get parent rest object.
+     * @returns - Parent rest object.
+     */
+    getRest(): MRest;
+    /**
+     * Get rhythm column this rest is in.
+     * @returns - Rhythm column.
+     */
+    getRhythmColumn(): MRhythmColumn;
+    /**
+     * Get the measure this rest is in.
+     * @returns - Measure.
+     */
+    getMeasure(): MMeasure;
+    /**
+     * Get staff notation line this rest is in.
+     * @returns - Staff object.
+     */
+    getStaff(): MStaff;
+}
+/** Rhythm column object. */
+declare class MRhythmColumn extends MusicInterface {
+    private readonly obj;
+    /** OBject name. */
+    static readonly Name = "RhythmColumn";
+    /** @internal */
+    constructor(obj: ObjRhythmColumn);
+    /** @internal */
+    getMusicObject(): ObjRhythmColumn;
+    /**
+     * Get symbol (note group or rest) of this column for given voice id.
+     * @param voiceId - Voice id.
+     * @returns - Note group, rest or undefined.
+     */
+    getRhythmSymbol(voiceId: VoiceId): MNoteGroup | MRest | undefined;
+    /**
+     * Get the measure this rhythm column is in.
+     * @returns - Measure.
+     */
+    getMeasure(): MMeasure;
+}
+/** Score row object. */
+declare class MScoreRow extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "ScoreRow";
+    /** @internal */
+    constructor(obj: ObjScoreRow);
+    /** @internal */
+    getMusicObject(): ObjScoreRow;
+    /**
+     * Parent music document.
+     * @returns - Parent music document.
+     */
+    getDocument(): MDocument;
+    /**
+     * Get measures of this score row.
+     * @returns - Array of measures.
+     */
+    getMeasures(): ReadonlyArray<MMeasure>;
+    /**
+     * Get notation lines (staves and tabs) of this score row.
+     * @returns - Array of staves and tabs.
+     */
+    getNotationLines(): ReadonlyArray<MStaff | MTab>;
+}
+/** Score row group object. */
+declare class MScoreRowGroup extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "ScoreRowGroup";
+    /** @internal */
+    constructor(obj: ObjScoreRowGroup);
+    /** @internal */
+    getMusicObject(): ObjScoreRowGroup;
+    /**
+     * Get instrument name.
+     * @returns - instrument name.
+     */
+    getInstrument(): string;
+}
+/** Staff notatio line object. */
+declare class MStaff extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Staff";
+    /** @internal */
+    constructor(obj: ObjStaff);
+    /** @internal */
+    getMusicObject(): ObjStaff;
+    /**
+     * Get index of this staff in score row.
+     * @returns - Index (0=top notation line).
+     */
+    getId(): number;
+    /**
+     * Get name of this staff.
+     * @returns - Staff name.
+     */
+    getName(): string | undefined;
+    /**
+     * Get the score row this staff is in.
+     * @returns - Score row.
+     */
+    getRow(): MScoreRow;
+}
+/** Guitar tab notation line object. */
+declare class MTab extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Tab";
+    /** @internal */
+    constructor(obj: ObjTab);
+    /** @internal */
+    getMusicObject(): ObjTab;
+    /**
+     * Get index of this guitar tab in score row.
+     * @returns - Index (0=top notation line).
+     */
+    getId(): number;
+    /**
+     * Get name of this guitar tab.
+     * @returns - Staff name.
+     */
+    getName(): string | undefined;
+    /**
+     * Get the score row this guitar tab is in.
+     * @returns - Score row.
+     */
+    getRow(): MScoreRow;
+}
+/** Staff signature object contains clef, key signature, time signature, tempo and measure number, all optional depending on measure. */
+declare class MStaffSignature extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "StaffSignature";
+    /** @internal */
+    constructor(obj: ObjStaffSignature);
+    /** @internal */
+    getMusicObject(): ObjStaffSignature;
+    /**
+     * Get staff notation line this signature is in.
+     * @returns - Staff object.
+     */
+    getStaff(): MStaff;
+}
+/** Tab signature object contains time signature, tempo and measure number, all optional depending on measure. */
+declare class MTabSignature extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "TabSignature";
+    /** @internal */
+    constructor(obj: ObjTabSignature);
+    /** @internal */
+    getMusicObject(): ObjTabSignature;
+    /**
+     * Get tab notation line this signature is in.
+     * @returns - Tab object.
+     */
+    getTab(): MTab;
+}
+/** Tab rhythm object. */
+declare class MTabRhythm extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "TabRhythm";
+    /** @internal */
+    constructor(obj: ObjTabRhythm);
+    /** @internal */
+    getMusicObject(): ObjTabRhythm;
+    /**
+     * Get measure.
+     * @returns - Measure.
+     */
+    getMeasure(): MMeasure;
+    /**
+     * Get tab.
+     * @returns - Tab.
+     */
+    getTab(): MTab;
+}
+/** Spacial text object contains text and possibly special symbols (e.g. Segno or Coda). */
+declare class MSpecialText extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "SpecialText";
+    /** @internal */
+    constructor(obj: ObjSpecialText);
+    /** @internal */
+    getMusicObject(): ObjSpecialText;
+    /**
+     * Get text content.
+     * @returns - Text content.
+     */
+    getText(): string;
+}
+/** Text object. */
+declare class MText extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Text";
+    /** @internal */
+    constructor(obj: ObjText);
+    /** @internal */
+    getMusicObject(): ObjText;
+    /**
+     * Get text content.
+     * @returns - Text content.
+     */
+    getText(): string;
+}
+/** Lyrics object. */
+declare class MLyrics extends MusicInterface {
+    private readonly obj;
+    /** Object name. */
+    static readonly Name = "Lyrics";
+    /** @internal */
+    constructor(obj: ObjLyrics);
+    /** @internal */
+    getMusicObject(): ObjLyrics;
+    /**
+     * Get lyrics text.
+     * @returns - Lyrics text.
+     */
+    getText(): string;
+}
+/** Extension line object. */
+declare class MExtensionLine extends MusicInterface {
+    private readonly obj;
+    /** OBject name. */
+    static readonly Name = "ExtensionLine";
+    /** @internal */
+    constructor(obj: ObjExtensionLine);
+    /** @internal */
+    getMusicObject(): ObjExtensionLine;
+}
+
+export { MTabSignature as $, type AnnotationText as A, MHeader as B, Connective as C, MImage as D, MMeasure as E, Fermata as F, MBarLineRight as G, MBarLineLeft as H, MStaffBarLine as I, MNoteGroup as J, MStaffNoteGroup as K, type LyricsOptions as L, MDocument as M, type NoteOptions as N, MTabNoteGroup as O, MRest as P, MStaffRest as Q, type RestOptions as R, StaffPreset as S, type TupletOptions as T, MRhythmColumn as U, type VoiceId as V, MScoreRow as W, MScoreRowGroup as X, MStaff as Y, MTab as Z, MStaffSignature as _, type ScoreConfiguration as a, MTabRhythm as a0, MSpecialText as a1, MText as a2, MLyrics as a3, MExtensionLine as a4, Clef as a5, type BaseConfig as a6, type StaffConfig as a7, type TabConfig as a8, getVoiceIds as a9, isVoiceId as aa, validateVoiceId as ab, type StringNumber as ac, getStringNumbers as ad, isStringNumber as ae, validateStringNumber as af, getVerseNumbers as ag, isVerseNumber as ah, validateVerseNumber as ai, Stem as aj, Arpeggio as ak, type StaffTabOrGroup as al, LyricsAlign as am, LyricsHyphen as an, DynamicsAnnotation as ao, TempoAnnotation as ap, PlayState as aq, type PlayStateChangeListener as ar, type MeasureOptions as b, type VerseNumber as c, type StaffTabOrGroups as d, Navigation as e, Annotation as f, Label as g, TieType as h, NoteAnchor as i, VerticalPosition as j, type ScoreEventType as k, ScoreEvent as l, ScoreStaffPosEvent as m, ScoreObjectEvent as n, type ScoreEventListener as o, MPlayer as p, MRenderContext as q, MPlaybackButtons as r, MusicInterface as s, MAccidental as t, MConnective as u, MArpeggio as v, MBeamGroup as w, MStaffBeamGroup as x, MEnding as y, MFermata as z };