@scorelabs/core 1.0.1

package/dist/models/Instrument.js

@@ -0,0 +1,56 @@
+export var InstrumentType;
+(function (InstrumentType) {
+    InstrumentType["String"] = "string";
+    InstrumentType["Brass"] = "brass";
+    InstrumentType["Woodwind"] = "woodwind";
+    InstrumentType["Percussion"] = "percussion";
+    InstrumentType["Keyboard"] = "keyboard";
+    InstrumentType["Synth"] = "synth";
+})(InstrumentType || (InstrumentType = {}));
+export var InstrumentPreset;
+(function (InstrumentPreset) {
+    InstrumentPreset["Piano"] = "piano";
+    InstrumentPreset["Violin"] = "violin";
+    InstrumentPreset["Cello"] = "cello";
+    InstrumentPreset["Guitar"] = "guitar";
+    InstrumentPreset["ElectricGuitar"] = "electric-guitar";
+    InstrumentPreset["Bass"] = "bass";
+    InstrumentPreset["Flute"] = "flute";
+    InstrumentPreset["Trumpet"] = "trumpet";
+    InstrumentPreset["Drums"] = "drums";
+})(InstrumentPreset || (InstrumentPreset = {}));
+export const PRESET_INSTRUMENTS = {
+    [InstrumentPreset.Piano]: {
+        name: 'Acoustic Grand Piano',
+        midiProgram: 0,
+        type: InstrumentType.Keyboard,
+    },
+    [InstrumentPreset.Violin]: { name: 'Violin', midiProgram: 40, type: InstrumentType.String },
+    [InstrumentPreset.Cello]: { name: 'Cello', midiProgram: 42, type: InstrumentType.String },
+    [InstrumentPreset.Guitar]: {
+        name: 'Acoustic Guitar (nylon)',
+        midiProgram: 24,
+        type: InstrumentType.String,
+    },
+    [InstrumentPreset.ElectricGuitar]: {
+        name: 'Electric Guitar (clean)',
+        midiProgram: 27,
+        type: InstrumentType.String,
+    },
+    [InstrumentPreset.Bass]: {
+        name: 'Acoustic Bass',
+        midiProgram: 32,
+        type: InstrumentType.String,
+    },
+    [InstrumentPreset.Flute]: { name: 'Flute', midiProgram: 73, type: InstrumentType.Woodwind },
+    [InstrumentPreset.Trumpet]: { name: 'Trumpet', midiProgram: 56, type: InstrumentType.Brass },
+    [InstrumentPreset.Drums]: {
+        name: 'Drum Kit',
+        midiProgram: 118,
+        type: InstrumentType.Percussion,
+    },
+};
+export function getInstrumentByProgram(program) {
+    const match = Object.values(PRESET_INSTRUMENTS).find((i) => i.midiProgram === program);
+    return match || PRESET_INSTRUMENTS[InstrumentPreset.Piano];
+}

package/dist/models/Measure.d.ts

@@ -0,0 +1,65 @@
+import { Note, NoteJSON } from './Note';
+import { NoteSet, NoteSetJSON } from './NoteSet';
+import { TimeSignature, KeySignature, Duration, Repeat, Volta, Clef, Tempo, BarlineStyle } from './types';
+/**
+ * Represents a single measure containing note sets, potentially in multiple voices.
+ */
+export declare class Measure {
+    readonly voices: NoteSet[][];
+    readonly timeSignature?: TimeSignature | undefined;
+    readonly keySignature?: KeySignature | undefined;
+    readonly systemBreak: boolean;
+    readonly pageBreak: boolean;
+    readonly repeats: Repeat[];
+    readonly volta?: Volta | undefined;
+    readonly isPickup: boolean;
+    readonly clef?: Clef | undefined;
+    readonly tempo?: Tempo | undefined;
+    readonly rehearsalMark?: string | undefined;
+    readonly systemText?: string | undefined;
+    readonly barlineStyle: BarlineStyle;
+    constructor(voices: NoteSet[][], timeSignature?: TimeSignature | undefined, keySignature?: KeySignature | undefined, systemBreak?: boolean, pageBreak?: boolean, repeats?: Repeat[], volta?: Volta | undefined, isPickup?: boolean, clef?: Clef | undefined, tempo?: Tempo | undefined, rehearsalMark?: string | undefined, systemText?: string | undefined, barlineStyle?: BarlineStyle);
+    get notes(): NoteSet[];
+    changeNoteDuration(noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Measure;
+    getTotalDuration(voiceIndex?: number): number;
+    static fromJSON(data: MeasureJSON): Measure;
+    transpose(semitones: number): Measure;
+    replaceNoteSet(index: number, newNoteSet: NoteSet, voiceIndex?: number): Measure;
+    replaceNote(noteIndex: number, newNote: Note, voiceIndex?: number): Measure;
+    deleteNote(noteIndex: number, voiceIndex?: number): Measure;
+    autoBeam(timeSign: TimeSignature): Measure;
+    withTimeSignature(timeSignature?: TimeSignature): Measure;
+    withKeySignature(keySignature?: KeySignature): Measure;
+    withClef(clef?: Clef): Measure;
+    withTempo(tempo?: Tempo): Measure;
+    withSystemBreak(systemBreak: boolean): Measure;
+    withPageBreak(pageBreak: boolean): Measure;
+    withVoices(voices: NoteSet[][]): Measure;
+    withVoiceNotes(notes: Note[], voiceIndex?: number): Measure;
+    withRepeat(repeat?: Repeat): Measure;
+    withRepeats(repeats: Repeat[]): Measure;
+    withVolta(volta?: Volta): Measure;
+    withPickup(isPickup: boolean): Measure;
+    withRehearsalMark(mark?: string): Measure;
+    withSystemText(text?: string): Measure;
+    withBarlineStyle(style: BarlineStyle): Measure;
+    fillVoiceWithRests(voiceIndex: number, targetDuration: number): Measure;
+    toJSON(): MeasureJSON;
+}
+export interface MeasureJSON {
+    notes?: NoteJSON[];
+    voices?: NoteSetJSON[][];
+    timeSignature?: TimeSignature;
+    keySignature?: KeySignature;
+    systemBreak?: boolean;
+    pageBreak?: boolean;
+    repeat?: Repeat;
+    repeats?: Repeat[];
+    volta?: Volta;
+    isPickup?: boolean;
+    clef?: string;
+    tempo?: Tempo;
+    rehearsalMark?: string;
+    systemText?: string;
+    barlineStyle?: BarlineStyle;
+}

package/dist/models/Measure.js

@@ -0,0 +1,291 @@
+import { Note } from './Note';
+import { NoteSet } from './NoteSet';
+import { DURATION_VALUES, decomposeDuration, BarlineStyle, } from './types';
+/**
+ * Represents a single measure containing note sets, potentially in multiple voices.
+ */
+export class Measure {
+    voices;
+    timeSignature;
+    keySignature;
+    systemBreak;
+    pageBreak;
+    repeats;
+    volta;
+    isPickup;
+    clef;
+    tempo;
+    rehearsalMark;
+    systemText;
+    barlineStyle;
+    constructor(voices, timeSignature, keySignature, systemBreak = false, pageBreak = false, repeats = [], volta, isPickup = false, clef, tempo, rehearsalMark, systemText, barlineStyle = BarlineStyle.Regular) {
+        this.voices = voices;
+        this.timeSignature = timeSignature;
+        this.keySignature = keySignature;
+        this.systemBreak = systemBreak;
+        this.pageBreak = pageBreak;
+        this.repeats = repeats;
+        this.volta = volta;
+        this.isPickup = isPickup;
+        this.clef = clef;
+        this.tempo = tempo;
+        this.rehearsalMark = rehearsalMark;
+        this.systemText = systemText;
+        this.barlineStyle = barlineStyle;
+        if (this.voices.length === 0) {
+            this.voices = [[]];
+        }
+    }
+    get notes() {
+        return this.voices[0] || [];
+    }
+    changeNoteDuration(noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+        const voice = this.voices[voiceIndex];
+        if (!voice || noteIndex < 0 || noteIndex >= voice.length)
+            return this;
+        const targetNoteSet = voice[noteIndex];
+        const oldVal = targetNoteSet.getDurationValue();
+        const base = DURATION_VALUES[newDuration];
+        const newVal = isDotted ? base * 1.5 : base;
+        if (Math.abs(newVal - oldVal) < 0.001)
+            return this;
+        const updatedVoice = [...voice];
+        if (newVal < oldVal) {
+            const gap = oldVal - newVal;
+            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, isDotted);
+            const rests = decomposeDuration(gap).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)]));
+            updatedVoice.splice(noteIndex + 1, 0, ...rests);
+        }
+        else {
+            const delta = newVal - oldVal;
+            let available = 0;
+            for (let i = noteIndex + 1; i < updatedVoice.length; i++) {
+                available += updatedVoice[i].getDurationValue();
+            }
+            if (available < delta - 0.001)
+                return this;
+            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, isDotted);
+            let consumed = 0;
+            let removeCount = 0;
+            const replacements = [];
+            for (let i = noteIndex + 1; i < voice.length; i++) {
+                const ns = voice[i];
+                const val = ns.getDurationValue();
+                if (consumed + val <= delta + 0.001) {
+                    consumed += val;
+                    removeCount++;
+                    if (consumed >= delta - 0.001)
+                        break;
+                }
+                else {
+                    const remaining = consumed + val - delta;
+                    replacements.push(...decomposeDuration(remaining).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)])));
+                    removeCount++;
+                    break;
+                }
+            }
+            updatedVoice.splice(noteIndex + 1, removeCount, ...replacements);
+        }
+        const newVoices = [...this.voices];
+        newVoices[voiceIndex] = updatedVoice;
+        return this.withVoices(newVoices);
+    }
+    getTotalDuration(voiceIndex = 0) {
+        const voice = this.voices[voiceIndex];
+        if (!voice)
+            return 0;
+        return voice.reduce((sum, ns) => sum + ns.getDurationValue(), 0);
+    }
+    static fromJSON(data) {
+        let voices;
+        if (data.voices) {
+            voices = data.voices.map((v) => v.map((n) => NoteSet.fromJSON(n)));
+        }
+        else if (data.notes) {
+            voices = [data.notes.map((n) => new NoteSet([Note.fromJSON(n)]))];
+        }
+        else {
+            voices = [[]];
+        }
+        return new Measure(voices, data.timeSignature, data.keySignature, data.systemBreak ?? false, data.pageBreak ?? false, data.repeats || (data.repeat ? [data.repeat] : []), data.volta, data.isPickup ?? false, data.clef, data.tempo, data.rehearsalMark, data.systemText, data.barlineStyle ?? BarlineStyle.Regular);
+    }
+    transpose(semitones) {
+        return this.withVoices(this.voices.map((v) => v.map((ns) => ns.transpose(semitones))));
+    }
+    replaceNoteSet(index, newNoteSet, voiceIndex = 0) {
+        if (index < 0 || voiceIndex < 0 || voiceIndex >= this.voices.length)
+            return this;
+        const voice = [...this.voices[voiceIndex]];
+        if (index >= voice.length)
+            return this;
+        voice[index] = newNoteSet;
+        const newVoices = [...this.voices];
+        newVoices[voiceIndex] = voice;
+        return this.withVoices(newVoices);
+    }
+    replaceNote(noteIndex, newNote, voiceIndex = 0) {
+        return this.replaceNoteSet(noteIndex, new NoteSet([newNote]), voiceIndex);
+    }
+    deleteNote(noteIndex, voiceIndex = 0) {
+        if (voiceIndex < 0 || voiceIndex >= this.voices.length)
+            return this;
+        const voice = [...this.voices[voiceIndex]];
+        if (noteIndex < 0 || noteIndex >= voice.length)
+            return this;
+        voice.splice(noteIndex, 1);
+        const newVoices = [...this.voices];
+        newVoices[voiceIndex] = voice;
+        return this.withVoices(newVoices);
+    }
+    autoBeam(timeSign) {
+        const newVoices = this.voices.map((voice) => {
+            let currentOffset = 0;
+            let lastGroupId = undefined;
+            let lastGroupStartTime = 0;
+            let lastGroupHasSixteenths = false;
+            const tempNoteSets = [];
+            for (const ns of voice) {
+                const noteDuration = ns.getDurationValue();
+                let groupToAssign = undefined;
+                if (ns.isBeamable()) {
+                    const isSixteenth = noteDuration < 0.5;
+                    let currentBeatLength = 4 / timeSign.beatType;
+                    if (timeSign.beatType === 8 && timeSign.beats % 3 === 0) {
+                        currentBeatLength = 1.5;
+                    }
+                    else if (timeSign.beatType === 4 && (timeSign.beats === 4 || timeSign.beats === 2)) {
+                        currentBeatLength = (lastGroupHasSixteenths || isSixteenth) ? 1.0 : 2.0;
+                    }
+                    else if (timeSign.beatType === 2 && timeSign.beats === 2) {
+                        currentBeatLength = (lastGroupHasSixteenths || isSixteenth) ? 1.0 : 2.0;
+                    }
+                    const currentBeatId = Math.floor(currentOffset / currentBeatLength + 0.001);
+                    const endOffset = currentOffset + noteDuration;
+                    const crossesBeat = Math.floor(endOffset / currentBeatLength - 0.001) !== currentBeatId;
+                    const sameBeatAsLast = lastGroupId !== undefined &&
+                        Math.floor(lastGroupStartTime / currentBeatLength + 0.001) === currentBeatId;
+                    if (sameBeatAsLast && !crossesBeat) {
+                        groupToAssign = lastGroupId;
+                        if (isSixteenth)
+                            lastGroupHasSixteenths = true;
+                    }
+                    else {
+                        lastGroupId = Math.floor(Math.random() * 1000000) + 1;
+                        lastGroupStartTime = currentOffset;
+                        lastGroupHasSixteenths = isSixteenth;
+                        groupToAssign = lastGroupId;
+                    }
+                }
+                else {
+                    lastGroupId = undefined;
+                    lastGroupHasSixteenths = false;
+                }
+                tempNoteSets.push(ns.withBeamGroup(groupToAssign));
+                currentOffset += noteDuration;
+            }
+            const groupCounts = new Map();
+            for (const ns of tempNoteSets) {
+                if (ns.beamGroup !== undefined) {
+                    groupCounts.set(ns.beamGroup, (groupCounts.get(ns.beamGroup) || 0) + 1);
+                }
+            }
+            return tempNoteSets.map((ns) => {
+                if (ns.beamGroup !== undefined && (groupCounts.get(ns.beamGroup) || 0) < 2) {
+                    return ns.withBeamGroup(undefined);
+                }
+                return ns;
+            });
+        });
+        return this.withVoices(newVoices);
+    }
+    withTimeSignature(timeSignature) {
+        return new Measure(this.voices, timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withKeySignature(keySignature) {
+        return new Measure(this.voices, this.timeSignature, keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withClef(clef) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withTempo(tempo) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withSystemBreak(systemBreak) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withPageBreak(pageBreak) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withVoices(voices) {
+        return new Measure(voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withVoiceNotes(notes, voiceIndex = 0) {
+        const newVoices = [...this.voices];
+        while (newVoices.length <= voiceIndex)
+            newVoices.push([]);
+        newVoices[voiceIndex] = notes.map((n) => new NoteSet([n]));
+        return this.withVoices(newVoices);
+    }
+    withRepeat(repeat) {
+        if (!repeat)
+            return this.withRepeats([]);
+        const existing = this.repeats.find((r) => r.type === repeat.type);
+        let newRepeats;
+        if (existing) {
+            newRepeats = this.repeats.filter((r) => r.type !== repeat.type);
+        }
+        else {
+            newRepeats = [...this.repeats, repeat];
+        }
+        return this.withRepeats(newRepeats);
+    }
+    withRepeats(repeats) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withVolta(volta) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withPickup(isPickup) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+    }
+    withRehearsalMark(mark) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, mark, this.systemText, this.barlineStyle);
+    }
+    withSystemText(text) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, text, this.barlineStyle);
+    }
+    withBarlineStyle(style) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, style);
+    }
+    fillVoiceWithRests(voiceIndex, targetDuration) {
+        const newVoices = [...this.voices];
+        while (newVoices.length <= voiceIndex) {
+            newVoices.push([]);
+        }
+        const currentVoice = newVoices[voiceIndex];
+        const currentDuration = currentVoice.reduce((sum, ns) => sum + ns.getDurationValue(), 0);
+        if (currentDuration < targetDuration - 0.001) {
+            const gap = targetDuration - currentDuration;
+            const rests = decomposeDuration(gap).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)]));
+            newVoices[voiceIndex] = [...currentVoice, ...rests];
+        }
+        return this.withVoices(newVoices);
+    }
+    toJSON() {
+        return {
+            voices: this.voices.map((v) => v.map((ns) => ns.toJSON())),
+            timeSignature: this.timeSignature,
+            keySignature: this.keySignature,
+            systemBreak: this.systemBreak || undefined,
+            pageBreak: this.pageBreak || undefined,
+            repeats: this.repeats,
+            volta: this.volta,
+            isPickup: this.isPickup || undefined,
+            clef: this.clef,
+            tempo: this.tempo,
+            rehearsalMark: this.rehearsalMark,
+            systemText: this.systemText,
+            barlineStyle: this.barlineStyle,
+        };
+    }
+}

package/dist/models/Note.d.ts

@@ -0,0 +1,116 @@
+import { Duration, Accidental, Articulation, Dynamic, Slur, Tuplet, Hairpin, Glissando, Arpeggio, Ottava, Pedal, Ornament, FretboardDiagram, NoteheadShape, Bowing } from './types';
+import { Pitch } from './Pitch';
+/**
+ * Represents a single note or rest in a measure.
+ */
+export declare class Note {
+    readonly duration: Duration;
+    readonly pitch?: Pitch | undefined;
+    readonly isRest: boolean;
+    readonly isDotted: boolean;
+    readonly accidental?: Accidental | undefined;
+    readonly beamGroup?: number | undefined;
+    readonly articulation?: Articulation | undefined;
+    readonly dynamic?: Dynamic | undefined;
+    readonly tie?: boolean | undefined;
+    readonly slur?: Slur | undefined;
+    readonly tuplet?: Tuplet | undefined;
+    readonly hairpin?: Hairpin | undefined;
+    readonly isGrace: boolean;
+    readonly lyric?: string | undefined;
+    readonly chord?: string | undefined;
+    readonly glissando?: Glissando | undefined;
+    readonly arpeggio?: Arpeggio | undefined;
+    readonly ottava?: Ottava | undefined;
+    readonly pedal?: Pedal | undefined;
+    readonly ornament?: Ornament | undefined;
+    readonly fret?: number | undefined;
+    readonly string?: number | undefined;
+    readonly fretboardDiagram?: FretboardDiagram | undefined;
+    readonly lyrics?: string[] | undefined;
+    readonly staffText?: string | undefined;
+    readonly color?: string | undefined;
+    readonly notehead?: NoteheadShape | undefined;
+    readonly bowing?: Bowing | undefined;
+    readonly fingering?: number | undefined;
+    constructor(duration: Duration, pitch?: Pitch | undefined, // undefined for rests
+    isRest?: boolean, isDotted?: boolean, accidental?: Accidental | undefined, beamGroup?: number | undefined, // Group ID for beamed notes
+    articulation?: Articulation | undefined, dynamic?: Dynamic | undefined, tie?: boolean | undefined, slur?: Slur | undefined, tuplet?: Tuplet | undefined, hairpin?: Hairpin | undefined, isGrace?: boolean, lyric?: string | undefined, chord?: string | undefined, glissando?: Glissando | undefined, arpeggio?: Arpeggio | undefined, ottava?: Ottava | undefined, pedal?: Pedal | undefined, ornament?: Ornament | undefined, fret?: number | undefined, string?: number | undefined, fretboardDiagram?: FretboardDiagram | undefined, lyrics?: string[] | undefined, staffText?: string | undefined, color?: string | undefined, notehead?: NoteheadShape | undefined, bowing?: Bowing | undefined, fingering?: number | undefined);
+    /**
+     * Get the duration value (quarter note = 1)
+     */
+    getDurationValue(): number;
+    /**
+     * Check if this note should be beamed (eighth or shorter)
+     */
+    isBeamable(): boolean;
+    withGrace(isGrace: boolean): Note;
+    withChord(chord?: string): Note;
+    transpose(semitones: number): Note;
+    transposeOctave(octaves: number): Note;
+    transposeDiatonic(steps: number): Note;
+    toggleEnharmonic(): Note;
+    withPitch(pitch: Pitch): Note;
+    withArticulation(articulation?: Articulation): Note;
+    withDynamic(dynamic?: Dynamic): Note;
+    withTie(tie?: boolean): Note;
+    withSlur(slur?: Slur): Note;
+    withTuplet(tuplet?: Tuplet): Note;
+    withLyric(lyric?: string): Note;
+    withLyrics(lyrics: string[]): Note;
+    withHairpin(hairpin?: Hairpin): Note;
+    withAccidental(accidental?: Accidental): Note;
+    withDuration(duration: Duration, isDotted?: boolean): Note;
+    withRest(isRest: boolean): Note;
+    withFretboardDiagram(diagram?: FretboardDiagram): Note;
+    withBeamGroup(beamGroup?: number): Note;
+    withGlissando(glissando?: Glissando): Note;
+    withArpeggio(arpeggio?: Arpeggio): Note;
+    withOttava(ottava?: Ottava): Note;
+    withPedal(pedal?: Pedal): Note;
+    withOrnament(ornament?: Ornament): Note;
+    withTab(fret: number, string: number): Note;
+    withStaffText(text?: string): Note;
+    withColor(color?: string): Note;
+    withNotehead(notehead?: NoteheadShape): Note;
+    withBowing(bowing?: Bowing): Note;
+    withFingering(fingering?: number): Note;
+    toJSON(): NoteJSON;
+    static fromJSON(data: NoteJSON): Note;
+}
+export interface NoteJSON {
+    duration: string;
+    pitch?: {
+        midiNumber: number;
+        step: number;
+        alter: number;
+        octave: number;
+    };
+    isRest?: boolean;
+    isDotted?: boolean;
+    accidental?: string;
+    beamGroup?: number;
+    articulation?: string;
+    dynamic?: string;
+    tie?: boolean;
+    slur?: Slur;
+    tuplet?: Tuplet;
+    hairpin?: Hairpin;
+    isGrace?: boolean;
+    lyric?: string;
+    chord?: string;
+    glissando?: Glissando;
+    arpeggio?: Arpeggio;
+    ottava?: Ottava;
+    pedal?: Pedal;
+    ornament?: Ornament;
+    fret?: number;
+    string?: number;
+    fretboardDiagram?: FretboardDiagram;
+    lyrics?: string[];
+    staffText?: string;
+    color?: string;
+    notehead?: string;
+    bowing?: string;
+    fingering?: number;
+}