@tspro/web-music-score 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1258 @@
+import * as React_2 from 'react';
+
+/** @public */
+export declare type Accidental = -2 | -1 | 0 | 1 | 2;
+
+/** @public */
+export declare type AlterTempo = {
+    beatsPerMinute: number;
+    options?: {
+        beatLength: NoteLength;
+        dotted?: boolean;
+    };
+};
+
+/** @public */
+export declare function alterTempoSpeed(tempo: Tempo, speed: number): Tempo;
+
+/** @public */
+export declare enum Annotation {
+    /** "ppp", "pp", "p", "mp", "m", "mf", "f", "ff", "fff", "cresc.", "decresc.", "dim." */
+    Dynamics = 0,
+    /** "accel.", "rit.", "a tempo" */
+    Tempo = 1
+}
+
+/** @public */
+export declare enum ArcPos {
+    Auto = 0,
+    Above = 1,
+    Middle = 2,
+    Below = 3,
+    StemTip = 4
+}
+
+/** @public */
+export declare enum Arpeggio {
+    Up = 0,
+    Down = 1
+}
+
+/** @public */
+declare namespace Audio_2 {
+    enum Instrument {
+        Synth = 0,
+        ClassicalGuitar = 1
+    }
+    const InstrumentList: Instrument[];
+    const DefaultInstrument = Instrument.Synth;
+    function validateInstrument(instr: number): Instrument;
+    function getInstrumentName(instr: Instrument): string;
+    function setInstrument(instr: Instrument): void;
+    function playNote(note: Note | string | number, duration?: number, linearVolume?: number): void;
+    function stop(): void;
+}
+export { Audio_2 as Audio }
+
+/** @public */
+export declare class CellData {
+    readonly guitarNote: Readonly<GuitarNote>;
+    readonly cellRect: DivRect;
+    readonly noteRect: DivRect;
+    constructor(guitarNote: Readonly<GuitarNote>, cellRect: DivRect, noteRect: DivRect);
+}
+
+/** @public */
+export declare class Chord {
+    readonly chordInfo: ChordInfo;
+    readonly rootNote: Note;
+    readonly name: string;
+    readonly notes: Note[];
+    readonly omitNotes: boolean[];
+    readonly slashBassNote?: Note;
+    private constructor();
+    static getChords(notes: ReadonlyArray<Note>): ReadonlyArray<Chord>;
+    private replaceWith;
+    /**
+     * @returns Chord name e.g. "C/B"
+     */
+    toString(): string;
+    /**
+     * @returns Degree notation string, e.g. "E - 1(C) - 3(E) - 5(G)"
+     */
+    getDegreeNotationString(): string;
+    /**
+     * @returns Omitted degrees string e.g. "Omits 5(G), 9(D)"
+     */
+    getOmittedDegreesString(): string;
+    /**
+     * @param i - Degree index
+     * @returns Degree string for given degree index, e.g. "3"
+     */
+    private getDegreeStr;
+    /**
+     * @param i - Degree index
+     * @returns Note string for given degree index, e.g. "E"
+     */
+    private getNoteStr;
+}
+
+/** @public */
+export declare type ChordInfo = {
+    name: string;
+    degrees: Degree[];
+};
+
+/** @public */
+export declare class CircleOfFifthsComponent extends React_2.Component<CircleOfFifthsComponentProps, {}> {
+    constructor(props: CircleOfFifthsComponentProps);
+    onScaleChange(scaleType: ScaleType, keyNote: string): void;
+    render(): React_2.JSX.Element;
+}
+
+/** @public */
+export declare interface CircleOfFifthsComponentProps {
+    style?: React_2.CSSProperties;
+    scale: Scale;
+    onScaleChange: (scale: Scale) => void;
+}
+
+/** @public */
+export declare type ClickObjectListener = (obj: MusicInterface) => void;
+
+/** @public */
+export declare type ClickObjectSelector = (arr: MusicInterface[]) => MusicInterface | undefined;
+
+/** @public */
+export declare type ClickPitchListener = (pickedPitch: PickedPitch) => void;
+
+/** @public */
+declare function createAndanteByDiabelli(): MDocument;
+
+/** @public */
+declare function createFrereJacques(): MDocument;
+
+/** @public */
+declare function createGreensleeves(): MDocument;
+
+/** @public */
+export declare type CursorPositionChangeListener = (cursorRect: DivRect | undefined) => void;
+
+declare namespace DefaultExport {
+    export {
+        Audio_2 as Audio,
+        MusicError,
+        MusicInterface,
+        MAccidental,
+        MArc,
+        MArpeggio,
+        MBeamGroup,
+        MDocument,
+        MEnding,
+        MFermata,
+        MHeader,
+        MImage,
+        MMeasure,
+        MBarLineRight,
+        MBarLineLeft,
+        MNoteGroup,
+        MRest,
+        MRhythmColumn,
+        MScoreRow,
+        MSignature,
+        MSpecialText,
+        MText,
+        MExtensionLine,
+        MPlayer,
+        MRenderer,
+        MPlaybackButtons,
+        DivRect,
+        StaffKind,
+        Stem,
+        Arpeggio,
+        TieLength,
+        ArcPos,
+        NoteOptions,
+        RestOptions,
+        PickedPitch,
+        ClickPitchListener,
+        ClickObjectSelector,
+        ClickObjectListener,
+        CursorPositionChangeListener,
+        PlayState,
+        PlayStateChangeListener,
+        Fermata,
+        Navigation,
+        Annotation,
+        Label,
+        ChordInfo,
+        InvalidChordException,
+        Chord,
+        validateIntervalQuality,
+        IntervalDirection,
+        IntervalQuality,
+        Interval,
+        Accidental,
+        NaturalNote,
+        ParsedNote,
+        Note,
+        getScaleFactoryList,
+        getScaleFactory,
+        validateScaleType,
+        getScale,
+        getDefaultScale,
+        Degree,
+        ScaleType,
+        Scale,
+        ScaleFactory,
+        getDefaultKeySignature,
+        KeySignature,
+        getDefaultTimeSignature,
+        TimeSignatureString,
+        TimeSignature,
+        getDefaultTempo,
+        getTempoString,
+        alterTempoSpeed,
+        Tempo,
+        AlterTempo,
+        validateNoteLength,
+        NoteLength,
+        MaxNoteLength,
+        MinNoteLength,
+        RhythmProps,
+        validatePitchNotation,
+        validateGuitarNoteLabel,
+        SymbolSet,
+        PitchNotation,
+        PitchNotationList,
+        DefaultPitchNotation,
+        GuitarNoteLabel,
+        DefaultGuitarNoteLabel,
+        GuitarNoteLabelList,
+        CircleOfFifthsComponentProps,
+        CircleOfFifthsComponent,
+        UpdateGuitarNoteFunc,
+        CellData,
+        GuitarComponentProps,
+        GuitarComponentState,
+        GuitarComponent,
+        validateTuningName,
+        validateHandedness,
+        TuningNameList,
+        DefaultTuningName,
+        Handedness,
+        DefaultHandedness,
+        GuitarNote,
+        GuitarContext,
+        MusicScoreViewProps,
+        MusicScoreView,
+        PlaybackButtonsLayout,
+        PlaybackButtonsProps,
+        PlaybackButtonsState,
+        PlaybackButtons,
+        SamplePieces
+    }
+}
+export default DefaultExport;
+
+/** @public */
+export declare const DefaultGuitarNoteLabel = GuitarNoteLabel.Default;
+
+/** @public */
+export declare const DefaultHandedness: Handedness;
+
+/** @public */
+export declare const DefaultPitchNotation = PitchNotation.Scientific;
+
+/** @public */
+export declare const DefaultTuningName: string;
+
+/** @public */
+export declare type Degree = 1 | 2 | "b3" | 3 | 4 | "b5" | 5 | "#5" | 6 | "bb7" | "b7" | 7 | "#7" | "b9" | 9 | "#9" | 11 | 13;
+
+/**
+ * @public
+ *
+ * DivRect class, left, top, right, bottom rectangle divided into four sections by centerX, centerY.
+ */
+export 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 o -
+     * @returns
+     */
+    equals(o: DivRect): boolean;
+    /**
+     * Check if frame (ignoring centerX/Y) of this Rect equals with given Rect, ignoring centerX and centerY.
+     *
+     * @param o -
+     * @returns
+     */
+    equalsFrame(o: DivRect): 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): this;
+    /**
+     * 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): this;
+    /**
+     * 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): this;
+    /**
+     * 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): this;
+    /**
+     * 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;
+}
+
+/** @public */
+export declare enum Fermata {
+    AtNote = 0,
+    AtMeasureEnd = 1
+}
+
+/** @public */
+export declare function getDefaultKeySignature(): KeySignature;
+
+/** @public */
+export declare function getDefaultScale(): Scale;
+
+/** @public */
+export declare function getDefaultTempo(): Readonly<Tempo>;
+
+/** @public */
+export declare function getDefaultTimeSignature(): TimeSignature;
+
+/** @public */
+export declare function getScale(keyNote: string, scaleType: ScaleType): Scale;
+
+/** @public */
+export declare function getScaleFactory(scaleType: ScaleType): ScaleFactory;
+
+/** @public */
+export declare function getScaleFactoryList(filter?: (scaleType: ScaleType) => boolean): ReadonlyArray<ScaleFactory | string>;
+
+/** @public */
+export declare function getTempoString(tempo: Tempo): string;
+
+/** @public */
+export declare class GuitarComponent extends React_2.Component<GuitarComponentProps, GuitarComponentState> {
+    state: GuitarComponentState;
+    constructor(props: GuitarComponentProps);
+    componentDidUpdate(prevProps: GuitarComponentProps): void;
+    getLayoutState(): {
+        table: CellData[][];
+        width: number;
+        height: number;
+    };
+    onHover(cell?: CellData): void;
+    onClick(cell?: CellData): void;
+    render(): React_2.JSX.Element;
+}
+
+/** @public */
+export declare interface GuitarComponentProps {
+    style?: React_2.CSSProperties;
+    guitarContext: GuitarContext;
+    updateGuitarNote?: UpdateGuitarNoteFunc;
+    onClickNote?: (guitarNote: GuitarNote) => void;
+}
+
+/** @public */
+export declare interface GuitarComponentState {
+    width: number;
+    height: number;
+    table: CellData[][];
+}
+
+/** @public */
+export declare class GuitarContext {
+    readonly tuningName: string;
+    readonly scale: Scale;
+    readonly handedness: Handedness;
+    readonly pitchNotation: PitchNotation;
+    readonly guitarNoteLabel: GuitarNoteLabel;
+    readonly maxFretId: number;
+    private readonly guitarNoteTable;
+    private readonly stringTunings;
+    constructor(tuningName: string, scale: Scale, handedness: Handedness, pitchNotation: PitchNotation, guitarNoteLabel: GuitarNoteLabel);
+    getGuitarNote(stringId: number, fretId: number): Readonly<GuitarNote>;
+    getStringTuning(stringId: number): Note;
+    getTuningOverview(): string;
+    alterTuningName(tuningName: string): GuitarContext;
+    alterScale(scale: Scale): GuitarContext;
+    alterHandedness(handedness: Handedness): GuitarContext;
+    alterPitchNotation(pitchNotation: PitchNotation): GuitarContext;
+    alterGuitarNoteLabel(guitarNoteLabel: GuitarNoteLabel): GuitarContext;
+}
+
+/** @public */
+export declare class GuitarNote {
+    readonly guitarCtx: GuitarContext;
+    readonly stringId: number;
+    readonly fretId: number;
+    readonly noteId: number;
+    readonly preferredNote: Note;
+    readonly isScaleNote: boolean;
+    readonly isScaleRootNote: boolean;
+    isVisible: boolean;
+    text: string;
+    textColor: string;
+    fillColor: string | undefined;
+    borderColor: string | undefined;
+    isBarre: boolean;
+    constructor(guitarCtx: GuitarContext, stringId: number, fretId: number, noteId: number);
+    show(): void;
+    hide(): void;
+    setDefaultText(): void;
+    setDefaultFillColor(): void;
+    setDefaultBorderColor(showBorder?: boolean): void;
+}
+
+/** @public */
+export declare enum GuitarNoteLabel {
+    Default = "Default",
+    OmitOctave = "Omit Octave",
+    Interval = "Interval"
+}
+
+/** @public */
+export declare const GuitarNoteLabelList: GuitarNoteLabel[];
+
+/** @public */
+export declare type Handedness = "rh" | "lh";
+
+/** @public */
+export declare class Interval {
+    readonly note1: Note;
+    readonly note2: Note;
+    readonly direction: IntervalDirection;
+    readonly semitones: number;
+    readonly quantity: number;
+    readonly quality: IntervalQuality;
+    private constructor();
+    static get(note1: Note, note2: Note): Interval | undefined;
+    toString(): string;
+    toAbbrString(): string;
+}
+
+/** @public */
+export declare type IntervalDirection = "Unison" | "Ascending" | "Descending";
+
+/** @public */
+export declare type IntervalQuality = "Perfect" | "Major" | "minor" | "Augmented" | "Doubly Augmented" | "diminished" | "doubly diminished";
+
+/** @public */
+export declare class InvalidChordException extends MusicError {
+    readonly msg: string;
+    constructor(msg: string);
+}
+
+/** @public */
+export declare class KeySignature {
+    private static readonly OrderOfSharps;
+    private static readonly OrderOfFlats;
+    private readonly accidentalNotes;
+    private readonly accidentalNotesByPitch;
+    private readonly orderedAccidentalNotes;
+    /**
+     * @param keyNote - Key note.
+     * @param mode - [1..7], 1 = Ionian/Major, 2 = Dorian, ..., 7 = Locrian
+     */
+    constructor(keyNote: string, mode: number);
+    getType(): "natural" | "flat" | "sharp";
+    getAccidental(pitch: number): Accidental;
+    getNumAccidentals(): number;
+    getOrderedAccidentalNotes(): ReadonlyArray<Note>;
+    /**
+     *
+     * @param degree - number 1..7 or string e.g "b5" or "#4"
+     * @returns
+     */
+    getScaleNote(degree: number | string): Note;
+    equals(o: KeySignature): boolean;
+}
+
+/** @public */
+export declare enum Label {
+    /** "C", "C#", "Db", "D", etc. */
+    Note = 0,
+    /** "C", "Am", "G7", etc. */
+    Chord = 1
+}
+
+/** @public */
+export declare class MAccidental extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Accidental";
+    getAccidental(): Accidental;
+}
+
+/** @public */
+export declare class MArc extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Arc";
+}
+
+/** @public */
+export declare class MArpeggio extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Arpeggio";
+}
+
+/** @public */
+export declare const MaxNoteLength = NoteLength.Whole;
+
+/** @public */
+export declare class MBarLineLeft extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "BarLineLeft";
+}
+
+/** @public */
+export declare class MBarLineRight extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "BarLineRight";
+}
+
+/** @public */
+export declare class MBeamGroup extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "BeamGroup";
+}
+
+/** @public */
+export declare class MDocument extends MusicInterface {
+    static readonly Name = "Document";
+    constructor(staffKind: StaffKind, measuresPerRow?: number);
+    setHeader(title?: string, composer?: string, arranger?: string): void;
+    getTitle(): string | undefined;
+    addMeasure(): MMeasure;
+    updateCursorRect(cursorRect?: DivRect): void;
+    play(playStateChangeListener?: PlayStateChangeListener): MPlayer;
+    static createSimpleScaleArpeggio(staffKind: StaffKind, scale: Scale, lowestPitchNote: string, numOctaves: number): MDocument;
+}
+
+/** @public */
+export declare class MEnding extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Ending";
+    getPassages(): ReadonlyArray<number>;
+    hasPassage(passage: number): boolean;
+}
+
+/** @public */
+export declare class MExtensionLine extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "ExtensionLine";
+}
+
+/** @public */
+export declare class MFermata extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Fermata";
+}
+
+/** @public */
+export declare class MHeader extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Header";
+    getTitle(): string | undefined;
+    getComposer(): string | undefined;
+    getArranger(): string | undefined;
+}
+
+/** @public */
+export declare class MImage extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Image";
+}
+
+/** @public */
+export declare const MinNoteLength = NoteLength.SixtyFourth;
+
+/** @public */
+export declare class MMeasure extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Measure";
+    getMeasureNumber(): number;
+    getRhythmColumns(): ReadonlyArray<MRhythmColumn>;
+    setKeySignature(keyNote: string, scaleType: ScaleType): MMeasure;
+    setKeySignature(keySignature: KeySignature): MMeasure;
+    setKeySignature(scale: Scale): MMeasure;
+    setTimeSignature(timeSignature: TimeSignature | TimeSignatureString): MMeasure;
+    setTempo(beatsPerMinute: number, beatLength?: NoteLength, dotted?: boolean): MMeasure;
+    addNote(voiceId: number, note: Note | string, noteLength: NoteLength, options?: NoteOptions): MMeasure;
+    addChord(voiceId: number, notes: (Note | string)[], noteLength: NoteLength, options?: NoteOptions): MMeasure;
+    addRest(voiceId: number, restLength: NoteLength, options?: RestOptions): MMeasure;
+    addFermata(fermata?: Fermata): MMeasure;
+    addNavigation(navigation: Navigation): MMeasure;
+    addNavigation(navigation: Navigation.EndRepeat, repeatCount: number): MMeasure;
+    addNavigation(navigation: Navigation.Ending, ...passages: number[]): MMeasure;
+    addLabel(label: Label, text: string): MMeasure;
+    addAnnotation(annotation: Annotation, text: string): MMeasure;
+    addExtension(extensionLength: NoteLength | number, extensionVisible?: boolean): MMeasure;
+    endSong(): MMeasure;
+    endSection(): MMeasure;
+    endRow(): MMeasure;
+    completeRests(voiceId?: number): MMeasure;
+}
+
+/** @public */
+export declare class MNoteGroup extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "NoteGroup";
+    getNotes(): ReadonlyArray<Note>;
+    getRhythmProps(): RhythmProps;
+}
+
+/** @public */
+export 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 | undefined): 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;
+}
+
+/** @public */
+export declare class MPlayer {
+    private static currentlyPlaying;
+    private readonly player;
+    constructor(doc: MDocument, playStateChangeListener?: PlayStateChangeListener);
+    static stopAll(): void;
+    play(): this;
+    pause(): this;
+    stop(): this;
+}
+
+/** @public */
+export declare class MRenderer {
+    private readonly renderer;
+    constructor();
+    setDocument(doc?: MDocument): this;
+    setCanvas(canvas: HTMLCanvasElement | string): this;
+    setClickPitchListener(fn: ClickPitchListener): void;
+    setClickObjectSelector(fn?: ClickObjectSelector): void;
+    setClickObjectListener(fn?: ClickObjectListener): void;
+    draw(): void;
+}
+
+/** @public */
+export declare class MRest extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Rest";
+    getRhythmProps(): RhythmProps;
+}
+
+/** @public */
+export declare class MRhythmColumn extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "RhythmColumn";
+    getRhythmSymbol(voiceId: number): MNoteGroup | MRest | undefined;
+}
+
+/** @public */
+export declare class MScoreRow extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "ScoreRow";
+    getMeasures(): ReadonlyArray<MMeasure>;
+}
+
+/** @public */
+export declare class MSignature extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Signature";
+}
+
+/** @public */
+export declare class MSpecialText extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "SpecialText";
+}
+
+/** @public */
+export declare class MText extends MusicInterface {
+    private readonly obj;
+    static readonly Name = "Text";
+    getText(): string;
+}
+
+/** @public */
+export declare class MusicError extends Error {
+    constructor(msg: string);
+}
+
+/** @public */
+export declare abstract class MusicInterface {
+    readonly name: string;
+    constructor(name: string);
+    getParent(): MusicInterface | undefined;
+}
+
+/**
+ * @public
+ *
+ * Usage:
+ *
+ *  import * as Score from "\@tspro/web-music-score";
+ *
+ *  \<Score.MusicScoreView doc=\{doc\} /\>
+ */
+export declare class MusicScoreView extends React_2.Component<MusicScoreViewProps, {}> {
+    renderer: MRenderer;
+    constructor(props: MusicScoreViewProps);
+    componentDidUpdate(prevProps: Readonly<MusicScoreViewProps>, prevState: Readonly<{}>): void;
+    render(): React_2.JSX.Element;
+}
+
+/** @public */
+export declare interface MusicScoreViewProps {
+    doc: MDocument;
+    onClickPitch?: ClickPitchListener;
+    onSelectObject?: ClickObjectSelector;
+    onClickObject?: ClickObjectListener;
+}
+
+/** @public */
+export declare type NaturalNote = "C" | "D" | "E" | "F" | "G" | "A" | "B";
+
+/** @public */
+export 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 */
+export declare class Note {
+    private static noteByNameCache;
+    private static noteByIdCache;
+    readonly pitch: number;
+    readonly accidental: Accidental;
+    constructor(pitch: number, accidental: number);
+    static getNote(noteName: string): Note;
+    static getNoteById(noteId: number, scale?: Scale): Note;
+    get pitchMod7(): number;
+    get octave(): number;
+    get noteId(): number;
+    get naturalNote(): NaturalNote;
+    getPitchInOctave(octave: number): number;
+    equals(note: Note): boolean;
+    format(pitchNotation: PitchNotation, symbolSet: SymbolSet): string;
+    formatOmitOctave(symbolSet: SymbolSet): string;
+    static replaceAccidentalSymbols(str: string, symbolSet: SymbolSet): string;
+    static isValidNoteName(noteName: string): boolean;
+    static parseNote(noteName: string): Readonly<ParsedNote> | undefined;
+    static getScientificNoteName(noteName: string, symbolSet: SymbolSet): string;
+    static getAccidentalSymbol(accidental: Accidental, symbolsSet: SymbolSet): string | undefined;
+    static getAccidental(accidentalSymbol: string): NonNullable<Accidental | undefined>;
+    static getNaturelNotePitch(naturalNote: string, octave?: number): number;
+    static getNaturalNote(pitch: number): NaturalNote;
+    static validatePitch(pitch: number): number;
+    static validateNoteId(noteId: number): number;
+    static validateNaturalNote(note: string): NaturalNote;
+    static validateOctave(octave: number): number;
+    static validateAccidental(acc: number): Accidental;
+    /**
+     * Sort notes by pitch in ascending order.
+     * @param notes - Array of notes.
+     * @returns Sorted array of notes.
+     */
+    static sort(notes: ReadonlyArray<Note>): Note[];
+    /**
+     * Remove duplicate notes.
+     * @param notes - Array of notes.
+     * @returns Sorted set of notes.
+     */
+    static removeDuplicates(notes: ReadonlyArray<Note>): Note[];
+    static compareFunc(a: Note, b: Note): 1 | -1 | 0;
+}
+
+/** @public */
+export declare enum NoteLength {
+    Whole = 192,// * 3 because triplets are multiplied by 2 / 3, integer result
+    Half = 96,
+    Quarter = 48,
+    Eighth = 24,
+    Sixteenth = 12,
+    ThirtySecond = 6,
+    SixtyFourth = 3
+}
+
+/** @public */
+export declare type NoteOptions = {
+    dotted?: boolean;
+    stem?: Stem;
+    color?: string;
+    arpeggio?: Arpeggio;
+    staccato?: boolean;
+    diamond?: boolean;
+    tieSpan?: number | TieLength;
+    tiePos?: ArcPos;
+    slurSpan?: number;
+    slurPos?: ArcPos;
+    triplet?: boolean;
+};
+
+/** @public */
+export declare type ParsedNote = {
+    naturalNote: NaturalNote;
+    accidental: Accidental;
+    octave?: number;
+};
+
+/** @public */
+export declare type PickedPitch = {
+    pitch: number;
+    measure: MMeasure;
+};
+
+/** @public */
+export declare enum PitchNotation {
+    Scientific = "Scientific",
+    Helmholtz = "Helmholtz"
+}
+
+/** @public */
+export declare const PitchNotationList: PitchNotation[];
+
+/**
+ * @public
+ *
+ * Usage:
+ *
+ *  import * as Score from "\@tspro/web-music-score";
+ *
+ *  \<Score.PlaybackButtons doc=\{doc\} /\>
+ *
+ * To set custom play, pause and stop labels:
+ *
+ *  \<Score.PlaybackButtons doc=\{doc\} playLabel="⏵" pauseLabel="⏸" stopLabel="⏹" /\>
+ *
+ * To use different button layout.
+ *
+ *  \<Score.PlaybackButtons doc=\{doc\} buttonLayout=\{Score.PlaybackButtonsLayout.PlayStopSingle\} /\>
+ *
+ */
+export declare class PlaybackButtons extends React_2.Component<PlaybackButtonsProps, PlaybackButtonsState> {
+    state: PlaybackButtonsState;
+    constructor(props: PlaybackButtonsProps);
+    componentDidUpdate(prevProps: Readonly<PlaybackButtonsProps>): void;
+    render(): React_2.JSX.Element;
+}
+
+/** @public */
+export declare enum PlaybackButtonsLayout {
+    PlayStopSingle = 0,
+    PlayStop = 1,
+    PlayPauseStop = 2
+}
+
+/** @public */
+export declare interface PlaybackButtonsProps {
+    doc: MDocument;
+    buttonLayout?: PlaybackButtonsLayout;
+    playLabel?: string;
+    pauseLabel?: string;
+    stopLabel?: string;
+}
+
+/** @public */
+export declare interface PlaybackButtonsState {
+    controller: MPlaybackButtons;
+}
+
+/** @public */
+export declare enum PlayState {
+    Playing = 0,
+    Paused = 1,
+    Stopped = 2
+}
+
+/** @public */
+export declare type PlayStateChangeListener = (playState: PlayState) => void;
+
+/** @public */
+export declare type RestOptions = {
+    dotted?: boolean;
+    pitch?: string | Note;
+    color?: string;
+    hide?: boolean;
+    triplet?: boolean;
+};
+
+/** @public */
+export declare class RhythmProps {
+    readonly noteLength: NoteLength;
+    readonly dotted: boolean;
+    readonly triplet: boolean;
+    readonly ticks: number;
+    readonly flagCount: number;
+    constructor(noteLength: NoteLength, dotted?: boolean, triplet?: boolean);
+    static createFromNoteSize(noteSize: number): RhythmProps;
+    canDot(): boolean;
+    hasStem(): boolean;
+    toString(): string;
+}
+
+export declare namespace SamplePieces {
+    export {
+        createFrereJacques,
+        createGreensleeves,
+        createAndanteByDiabelli
+    }
+}
+
+/** @public */
+export declare class Scale {
+    readonly keyNote: string;
+    readonly scaleType: ScaleType;
+    private readonly keySignature;
+    private readonly scaleDegrees;
+    private readonly accidentalNotes;
+    constructor(keyNote: string, scaleType: ScaleType);
+    equals(o: Scale): boolean;
+    static parseDegree(degree: number | string): {
+        deg: number;
+        acc: number;
+    };
+    getScaleName(symbolSet?: SymbolSet): string;
+    getScaleNotes(lowestPitchNote: string, numOctaves: number): Note[];
+    getScaleOverview(): string;
+    getScaleSteps(): number[];
+    getScaleStringSteps(): string[];
+    getKeySignature(): KeySignature;
+    getAccidental(pitch: number): Accidental;
+    isScaleNote(note: Note): boolean;
+    isScaleRootNote(note: Note): boolean;
+    getIntervalFromRootNote(note: Note): Interval;
+    getPreferredNote(noteId: number): Note;
+    private preferredChromaticNoteCache;
+    private getPreferredChromaticNote;
+}
+
+/** @public */
+export declare class ScaleFactory {
+    readonly type: ScaleType;
+    private keyNoteList;
+    private scaleMap;
+    constructor(type: ScaleType);
+    getKeyNoteList(): ReadonlyArray<string>;
+    getDefaultKeyNote(): string;
+    getType(): ScaleType;
+    getScale(keyNote: string): Scale;
+    hasScale(keyNote: string): boolean;
+}
+
+/** @public */
+export declare enum ScaleType {
+    Major = "Major",
+    NaturalMinor = "Natural Minor",
+    HarmonicMinor = "Harmonic Minor",
+    Ionian = "Ionian",
+    Dorian = "Dorian",
+    Phrygian = "Phrygian",
+    Lydian = "Lydian",
+    Mixolydian = "Mixolydian",
+    Aeolian = "Aeolian",
+    Locrian = "Locrian",
+    MajorPentatonic = "Major Pentatonic",
+    MinorPentatonic = "Minor Pentatonic",
+    MajorHexatonicBlues = "Major Hexatonic Blues",
+    MinorHexatonicBlues = "Minor Hexatonic Blues",
+    HeptatonicBlues = "Heptatonic Blues"
+}
+
+/** @public */
+export declare enum StaffKind {
+    /** Treble staff has treble (G-) clef. */
+    Treble = 0,
+    /** TrebleForGuitar has treble clef but is one octave lower. */
+    TrebleForGuitar = 1,
+    /** Bass staff has bass (F-) clef. */
+    Bass = 2,
+    /** Grand staff has both treble and bass clefs. */
+    Grand = 3
+}
+
+/** @public */
+export declare enum Stem {
+    Auto = 0,
+    Up = 1,
+    Down = 2
+}
+
+/** @public */
+export declare enum SymbolSet {
+    Ascii = 0,
+    Unicode = 1
+}
+
+/** @public */
+export declare type Tempo = {
+    beatsPerMinute: number;
+    options: {
+        beatLength: NoteLength;
+        dotted: boolean;
+    };
+};
+
+/** @public */
+export declare enum TieLength {
+    Short = "Short",
+    ToMeasureEnd = "ToMeasureEnd"
+}
+
+/** @public */
+export declare class TimeSignature {
+    readonly beatCount: number;
+    readonly beatSize: number;
+    /** Lengths in ticks */
+    readonly beatLength: NoteLength;
+    readonly measureTicks: number;
+    readonly beamGroupCount: number;
+    readonly beamGroupLength: number;
+    /**
+     * @param str - For example "4/4".
+     */
+    constructor(str: TimeSignatureString);
+    /**
+     * @param beatCount - Measure beat count.
+     * @param beatSize - Size value: whole-note=1, half-note=2, quarter-note=4, etc.
+     */
+    constructor(beatCount: number, beatSize: number);
+    is(beatCount: number, beatSize: number): boolean;
+    toString(): string;
+}
+
+/** @public */
+export declare type TimeSignatureString = "2/4" | "3/4" | "4/4" | "6/8" | "9/8";
+
+/** @public */
+export declare const TuningNameList: ReadonlyArray<string>;
+
+/** @public */
+export declare type UpdateGuitarNoteFunc = (guitarNote: GuitarNote) => void;
+
+/** @public */
+export declare function validateGuitarNoteLabel(kind: string): GuitarNoteLabel;
+
+/** @public */
+export declare function validateHandedness(handedness: string): Handedness;
+
+/** @public */
+export declare function validateIntervalQuality(q: string): IntervalQuality;
+
+/** @public */
+export declare function validateNoteLength(noteLength: unknown): NoteLength;
+
+/** @public */
+export declare function validatePitchNotation(pn: string): PitchNotation;
+
+/** @public */
+export declare function validateScaleType(scaleTypeStr: string): ScaleType;
+
+/** @public */
+export declare function validateTuningName(tuningName: string): string;
+
+export { }