@scorelabs/core 1.0.5 → 1.0.9

package/README.md

@@ -36,7 +36,7 @@ console.log(`Number of Parts: ${score.parts.length}`);
 The core model uses `NoteSet` to represent a collection of notes at a specific point data (e.g., a chord or a single note).
 
 ```typescript
-import { Note, NoteSet, Pitch, Duration } from '@scorelabs/core';
+import { Duration, Note, NoteSet, Pitch } from '@scorelabs/core';
 
 // Create a C4 quarter note
 const c4 = new Note(new Pitch('C', 4), Duration.Quarter);

package/dist/importers/MusicXMLParser.d.ts

@@ -12,8 +12,9 @@ export declare class MusicXMLParser {
     private currentSymbol;
     private instrumentPitchMap;
     private _domParser;
-    constructor(domParserInstance?: any);
+    constructor(domParserInstance?: DOMParser | unknown);
     private parseFromString;
+    static getXMLFromBinary(data: ArrayBuffer, domParser?: DOMParser | unknown): Promise<string>;
     parseBinary(data: ArrayBuffer): Promise<ScoreJSON>;
     parse(xmlString: string): ScoreJSON;
     private parseSubtitle;

package/dist/importers/MusicXMLParser.js

@@ -1,6 +1,6 @@
 import JSZip from 'jszip';
-import { getInstrumentByProgram } from '../models/Instrument';
-import { Clef, Duration, Accidental, Articulation, BarlineStyle, HairpinType, OttavaType, Ornament, Bowing, StemDirection, GlissandoType, NoteheadShape, Arpeggio, } from '../models/types';
+import { getInstrumentByProgram, guessInstrumentByName } from '../models/Instrument';
+import { Accidental, Arpeggio, Articulation, BarlineStyle, Bowing, Clef, DURATION_VALUES, Duration, GlissandoType, HairpinType, NoteheadShape, Ornament, OttavaType, StemDirection, decomposeDuration, } from '../models/types';
 /**
  * MusicXML Parser
  *
@@ -24,14 +24,17 @@ export class MusicXMLParser {
         }
         return this._domParser.parseFromString(xmlString, 'application/xml');
     }
-    async parseBinary(data) {
+    static async getXMLFromBinary(data, domParser) {
         const uint8 = new Uint8Array(data);
         if (uint8[0] === 0x50 && uint8[1] === 0x4b) {
             const zip = await JSZip.loadAsync(data);
             const containerXml = await zip.file('META-INF/container.xml')?.async('text');
             if (!containerXml)
                 throw new Error('Invalid MXL: Missing META-INF/container.xml');
-            const containerDoc = this.parseFromString(containerXml);
+            const _parser = domParser || (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
+            if (!_parser)
+                throw new Error('No DOMParser available');
+            const containerDoc = _parser.parseFromString(containerXml, 'application/xml');
             const rootfile = containerDoc.querySelector('rootfile');
             const fullPath = rootfile?.getAttribute('full-path');
             if (!fullPath)
@@ -39,13 +42,17 @@ export class MusicXMLParser {
             const scoreXml = await zip.file(fullPath)?.async('text');
             if (!scoreXml)
                 throw new Error(`Invalid MXL: Could not find file ${fullPath}`);
-            return this.parse(scoreXml);
+            return scoreXml;
         }
         else {
             const decoder = new TextDecoder();
-            return this.parse(decoder.decode(data));
+            return decoder.decode(data);
         }
     }
+    async parseBinary(data) {
+        const scoreXml = await MusicXMLParser.getXMLFromBinary(data, this._domParser);
+        return this.parse(scoreXml);
+    }
     parse(xmlString) {
         this.instrumentPitchMap.clear();
         // Strip potential BOM and leading garbage
@@ -144,19 +151,28 @@ export class MusicXMLParser {
         for (const scorePart of Array.from(scoreParts)) {
             const id = scorePart.getAttribute('id');
             const name = this.getText(scorePart, 'part-name') || 'Part';
-            let instrument = getInstrumentByProgram(0); // Default Piano
+            let instrument;
             // Find first midi-instrument to determine main instrument
             const firstMidiInst = scorePart.querySelector('midi-instrument');
             if (firstMidiInst) {
                 const programStr = this.getText(firstMidiInst, 'midi-program');
                 if (programStr) {
                     const program = parseInt(programStr);
-                    // MusicXML uses 1-128, MIDI uses 0-127. Adjust if needed.
-                    // Often it's accurate to 1-based, so checking bounds.
-                    // Assuming input is 1-based as per standard
                     instrument = getInstrumentByProgram(Math.max(0, program - 1));
                 }
             }
+            // Fallback: guess by part name
+            if (!instrument || instrument.sound === 'piano') {
+                const guessed = guessInstrumentByName(name);
+                // Only override if the guess is more specific than default piano
+                if (guessed.sound !== 'piano') {
+                    instrument = guessed;
+                }
+            }
+            // Final default
+            if (!instrument) {
+                instrument = getInstrumentByProgram(0);
+            }
             if (id) {
                 partInfo.set(id, { name: name.trim(), instrument });
             }
@@ -235,7 +251,8 @@ export class MusicXMLParser {
                     const sign = this.getText(clef, 'sign');
                     if (sign && number <= numStaves) {
                         const line = this.getNumber(clef, 'line') || 0;
-                        staffClefs[number - 1] = this.mapClef(sign, line);
+                        const octaveChange = this.getNumber(clef, 'clef-octave-change') || 0;
+                        staffClefs[number - 1] = this.mapClef(sign, line, octaveChange);
                     }
                 });
                 const staffDetails = attributes.querySelectorAll('staff-details');
@@ -251,7 +268,10 @@ export class MusicXMLParser {
             let systemText = undefined;
             let contextDynamic = undefined;
             const { repeats, volta, barlineStyle } = this.parseBarlines(measureElement);
-            const measureVoices = Array.from({ length: numStaves }, () => []);
+            // Map of staffIndex -> Map of voiceId -> NoteSetJSON[]
+            const staffVoices = new Map();
+            for (let i = 0; i < numStaves; i++)
+                staffVoices.set(i, new Map());
             const children = Array.from(measureElement.children);
             let pendingChord = undefined;
             let currentNoteSetMap = new Map();
@@ -368,6 +388,11 @@ export class MusicXMLParser {
                             note.pedal = currentPedal;
                             currentPedal = undefined;
                         }
+                        const voiceId = this.getText(child, 'voice') || '1';
+                        const voiceMap = staffVoices.get(staffIdx);
+                        if (!voiceMap.has(voiceId))
+                            voiceMap.set(voiceId, []);
+                        const voiceNoteSets = voiceMap.get(voiceId);
                         if (isChord) {
                             const existing = currentNoteSetMap.get(staffIdx);
                             if (existing)
@@ -378,26 +403,42 @@ export class MusicXMLParser {
                         else {
                             const existing = currentNoteSetMap.get(staffIdx);
                             if (existing)
-                                measureVoices[staffIdx].push({ notes: existing });
+                                voiceNoteSets.push({ notes: existing });
                             currentNoteSetMap.set(staffIdx, [note]);
                         }
                     }
                 }
                 else if (child.nodeName === 'backup' || child.nodeName === 'forward') {
                     for (const [sIdx, notes] of currentNoteSetMap.entries()) {
-                        if (notes.length > 0)
-                            measureVoices[sIdx].push({ notes });
+                        if (notes.length > 0) {
+                            const voiceId = this.getText(child.previousElementSibling, 'voice') || '1';
+                            const voiceMap = staffVoices.get(sIdx);
+                            if (!voiceMap.has(voiceId))
+                                voiceMap.set(voiceId, []);
+                            voiceMap.get(voiceId).push({ notes });
+                        }
                     }
                     currentNoteSetMap.clear();
                 }
             });
             for (const [sIdx, notes] of currentNoteSetMap.entries()) {
-                if (notes.length > 0)
-                    measureVoices[sIdx].push({ notes });
+                if (notes.length > 0) {
+                    // Last note in measure
+                    const voiceId = '1'; // Defaulting to 1 for final push if not tracked
+                    const voiceMap = staffVoices.get(sIdx);
+                    if (!voiceMap.has(voiceId))
+                        voiceMap.set(voiceId, []);
+                    voiceMap.get(voiceId).push({ notes });
+                }
             }
             for (let i = 0; i < numStaves; i++) {
+                const vMap = staffVoices.get(i);
+                let voicesIndices = Array.from(vMap.keys()).sort();
+                if (voicesIndices.length === 0)
+                    voicesIndices = ['1'];
+                const voices = voicesIndices.map(id => vMap.get(id) || []);
                 const measure = {
-                    voices: [measureVoices[i]],
+                    voices: voices,
                     timeSignature: measureTimeSignature,
                     keySignature: measureKeySignature,
                     isPickup: isPickup || undefined,
@@ -408,6 +449,30 @@ export class MusicXMLParser {
                     systemText: i === 0 ? systemText : undefined,
                     barlineStyle,
                 };
+                // Padding with rests if not a pickup
+                if (!isPickup) {
+                    const targetDur = (this.currentBeats * 4) / this.currentBeatType;
+                    measure.voices = measure.voices.map((v) => {
+                        const currentDur = v.reduce((sum, ns) => {
+                            const base = DURATION_VALUES[ns.notes[0].duration];
+                            return sum + (ns.notes[0].isDotted ? base * 1.5 : base);
+                        }, 0);
+                        if (currentDur < targetDur - 0.001) {
+                            const gap = targetDur - currentDur;
+                            const rests = decomposeDuration(gap).map((d) => ({
+                                notes: [
+                                    {
+                                        duration: d.duration,
+                                        isRest: true,
+                                        isDotted: d.isDotted,
+                                    },
+                                ],
+                            }));
+                            return [...v, ...rests];
+                        }
+                        return v;
+                    });
+                }
                 staves[i].measures.push(measure);
                 staves[i].clef = staffClefs[i];
             }
@@ -788,22 +853,30 @@ export class MusicXMLParser {
                 else if (barStyle === 'dotted')
                     barlineStyle = BarlineStyle.Dotted;
             }
-            if (barline.querySelector('repeat'))
+            const repeatEl = barline.querySelector('repeat');
+            if (repeatEl) {
+                const direction = repeatEl.getAttribute('direction');
+                const times = repeatEl.getAttribute('times');
                 repeats.push({
-                    type: barline.querySelector('repeat')?.getAttribute('direction') === 'forward'
-                        ? 'start'
-                        : 'end',
+                    type: direction === 'forward' ? 'start' : 'end',
+                    times: times ? parseInt(times) : undefined,
                 });
+            }
             const ending = barline.querySelector('ending');
             if (ending) {
                 const type = ending.getAttribute('type');
-                const number = parseInt(ending.getAttribute('number') || '1');
+                const numberAttr = ending.getAttribute('number') || '1';
+                // Handle "1,2" or "1 2"
+                const numbers = numberAttr
+                    .split(/[,\s]+/)
+                    .map((n) => parseInt(n))
+                    .filter((n) => !isNaN(n));
                 if (type === 'start')
-                    volta = { type: 'start', number };
+                    volta = { type: 'start', numbers };
                 else if (type === 'stop')
-                    volta = { type: 'stop', number };
+                    volta = { type: 'stop', numbers };
                 else if (type === 'discontinue')
-                    volta = { type: 'both', number };
+                    volta = { type: 'both', numbers };
             }
         });
         return { repeats, volta, barlineStyle };
@@ -876,12 +949,12 @@ export class MusicXMLParser {
         };
         return map[type] ?? Duration.Quarter;
     }
-    mapClef(sign, line = 0) {
+    mapClef(sign, line = 0, octaveChange = 0) {
         switch (sign.toUpperCase()) {
             case 'G':
-                return Clef.Treble;
+                return octaveChange === -1 ? Clef.Treble8vaBassa : Clef.Treble;
             case 'F':
-                return Clef.Bass;
+                return octaveChange === -1 ? Clef.Bass8vaBassa : Clef.Bass;
             case 'C':
                 return line === 4 ? Clef.Tenor : Clef.Alto;
             case 'PERCUSSION':

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from './models';
-export * from './importers';
+export * from './models/index.js';
+export * from './importers/index.js';

package/dist/index.js

@@ -1,2 +1,2 @@
-export * from './models';
-export * from './importers';
+export * from './models/index.js';
+export * from './importers/index.js';

package/dist/models/Instrument.d.ts

@@ -1,27 +1,16 @@
-export declare enum InstrumentType {
-    String = "string",
-    Brass = "brass",
-    Woodwind = "woodwind",
-    Percussion = "percussion",
-    Keyboard = "keyboard",
-    Synth = "synth"
-}
-export declare enum InstrumentPreset {
-    Piano = "piano",
-    Violin = "violin",
-    Cello = "cello",
-    Guitar = "guitar",
-    ElectricGuitar = "electric-guitar",
-    Bass = "bass",
-    Flute = "flute",
-    Trumpet = "trumpet",
-    Drums = "drums"
-}
+import { InstrumentPreset } from '../types/InstrumentPreset.js';
+import { InstrumentType } from '../types/InstrumentType.js';
 export interface Instrument {
     name: string;
     midiProgram: number;
+    sound: InstrumentPreset;
     type?: InstrumentType;
     transposition?: number;
 }
 export declare const PRESET_INSTRUMENTS: Record<string, Instrument>;
+export declare const TRANSLATED_INSTRUMENT_NAMES: Record<string, Record<InstrumentPreset, string>>;
 export declare function getInstrumentByProgram(program: number): Instrument;
+/**
+ * Guesses the instrument based on a string (like part name).
+ */
+export declare function guessInstrumentByName(name: string): Instrument;

package/dist/models/Instrument.js

@@ -1,67 +1,121 @@
-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 = {}));
+import { InstrumentPreset } from '../types/InstrumentPreset.js';
+import { InstrumentType } from '../types/InstrumentType.js';
 export const PRESET_INSTRUMENTS = {
     [InstrumentPreset.Piano]: {
         name: 'Acoustic Grand Piano',
         midiProgram: 0,
+        sound: InstrumentPreset.Piano,
         type: InstrumentType.Keyboard,
     },
-    [InstrumentPreset.Violin]: { name: 'Violin', midiProgram: 40, type: InstrumentType.String },
-    [InstrumentPreset.Cello]: { name: 'Cello', midiProgram: 42, type: InstrumentType.String },
+    [InstrumentPreset.Violin]: {
+        name: 'Violin',
+        midiProgram: 40,
+        sound: InstrumentPreset.Violin,
+        type: InstrumentType.String,
+    },
+    [InstrumentPreset.Cello]: {
+        name: 'Cello',
+        midiProgram: 42,
+        sound: InstrumentPreset.Cello,
+        type: InstrumentType.String,
+    },
     [InstrumentPreset.Guitar]: {
         name: 'Acoustic Guitar (nylon)',
         midiProgram: 24,
+        sound: InstrumentPreset.Guitar,
         type: InstrumentType.String,
     },
     [InstrumentPreset.ElectricGuitar]: {
         name: 'Electric Guitar (clean)',
         midiProgram: 27,
+        sound: InstrumentPreset.ElectricGuitar,
         type: InstrumentType.String,
     },
     [InstrumentPreset.Bass]: {
         name: 'Acoustic Bass',
         midiProgram: 32,
+        sound: InstrumentPreset.Bass,
         type: InstrumentType.String,
     },
     [InstrumentPreset.Flute]: {
         name: 'Flute',
         midiProgram: 73,
+        sound: InstrumentPreset.Flute,
         type: InstrumentType.Woodwind,
         transposition: 0,
     },
     [InstrumentPreset.Trumpet]: {
         name: 'Trumpet',
         midiProgram: 56,
+        sound: InstrumentPreset.Trumpet,
         type: InstrumentType.Brass,
         transposition: -2,
     },
     [InstrumentPreset.Drums]: {
         name: 'Drum Kit',
         midiProgram: 118,
+        sound: InstrumentPreset.Drums,
         type: InstrumentType.Percussion,
         transposition: 0,
     },
 };
+export const TRANSLATED_INSTRUMENT_NAMES = {
+    en: {
+        [InstrumentPreset.Piano]: 'Acoustic Grand Piano',
+        [InstrumentPreset.Violin]: 'Violin',
+        [InstrumentPreset.Cello]: 'Cello',
+        [InstrumentPreset.Guitar]: 'Acoustic Guitar',
+        [InstrumentPreset.ElectricGuitar]: 'Electric Guitar',
+        [InstrumentPreset.Bass]: 'Acoustic Bass',
+        [InstrumentPreset.Flute]: 'Flute',
+        [InstrumentPreset.Trumpet]: 'Trumpet',
+        [InstrumentPreset.Drums]: 'Drum Kit',
+    },
+    ca: {
+        [InstrumentPreset.Piano]: 'Piano',
+        [InstrumentPreset.Violin]: 'Violí',
+        [InstrumentPreset.Cello]: 'Violoncel',
+        [InstrumentPreset.Guitar]: 'Guitarra Acústica',
+        [InstrumentPreset.ElectricGuitar]: 'Guitarra Elèctrica',
+        [InstrumentPreset.Bass]: 'Baix',
+        [InstrumentPreset.Flute]: 'Flauta',
+        [InstrumentPreset.Trumpet]: 'Trompeta',
+        [InstrumentPreset.Drums]: 'Bateria',
+    },
+};
 export function getInstrumentByProgram(program) {
     const match = Object.values(PRESET_INSTRUMENTS).find((i) => i.midiProgram === program);
     return match || PRESET_INSTRUMENTS[InstrumentPreset.Piano];
 }
+/**
+ * Guesses the instrument based on a string (like part name).
+ */
+export function guessInstrumentByName(name) {
+    const n = name.toLowerCase();
+    if (n.includes('piano'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Piano];
+    if (n.includes('violin'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Violin];
+    if (n.includes('cello') || n.includes('violoncel'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Cello];
+    if (n.includes('electric guitar'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.ElectricGuitar];
+    if (n.includes('guitar'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Guitar];
+    if (n.includes('bass') || n.includes('baixo') || n.includes('baix'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Bass];
+    if (n.includes('flute') || n.includes('flauta'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Flute];
+    if (n.includes('trumpet') || n.includes('trompeta'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Trumpet];
+    if (n.includes('drum') || n.includes('perc') || n.includes('bateria'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Drums];
+    // Try partial matches for strings, brass, etc.
+    if (n.includes('string'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Violin];
+    if (n.includes('brass'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Trumpet];
+    if (n.includes('wind'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Flute];
+    return PRESET_INSTRUMENTS[InstrumentPreset.Piano];
+}

package/dist/models/Measure.d.ts

@@ -1,6 +1,6 @@
 import { Note, NoteJSON } from './Note';
 import { NoteSet, NoteSetJSON } from './NoteSet';
-import { TimeSignature, KeySignature, Duration, Repeat, Volta, Clef, Tempo, BarlineStyle } from './types';
+import { BarlineStyle, Clef, Duration, KeySignature, Repeat, Tempo, TimeSignature, Volta } from './types';
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */
@@ -20,6 +20,8 @@ export declare class Measure {
     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[];
+    get hasStartRepeat(): boolean;
+    get hasEndRepeat(): boolean;
     changeNoteDuration(noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Measure;
     getTotalDuration(voiceIndex?: number): number;
     static fromJSON(data: MeasureJSON): Measure;

package/dist/models/Measure.js

@@ -1,6 +1,6 @@
 import { Note } from './Note';
 import { NoteSet } from './NoteSet';
-import { DURATION_VALUES, decomposeDuration, BarlineStyle, } from './types';
+import { BarlineStyle, DURATION_VALUES, decomposeDuration, } from './types';
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */
@@ -39,6 +39,12 @@ export class Measure {
     get notes() {
         return this.voices[0] || [];
     }
+    get hasStartRepeat() {
+        return this.repeats.some((r) => r.type === "start");
+    }
+    get hasEndRepeat() {
+        return this.repeats.some((r) => r.type === "end");
+    }
     changeNoteDuration(noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
         const voice = this.voices[voiceIndex];
         if (!voice || noteIndex < 0 || noteIndex >= voice.length)

package/dist/models/Note.d.ts

@@ -1,5 +1,5 @@
-import { Duration, Accidental, Articulation, Dynamic, Slur, Tuplet, Hairpin, Glissando, Arpeggio, Ottava, Pedal, Ornament, FretboardDiagram, NoteheadShape, Bowing, Lyric, StemDirection } from './types';
 import { Pitch } from './Pitch';
+import { Accidental, Arpeggio, Articulation, Bowing, Duration, Dynamic, FretboardDiagram, Glissando, Hairpin, Lyric, NoteheadShape, Ornament, Ottava, Pedal, Slur, StemDirection, Tuplet } from './types';
 /**
  * Represents a single note or rest in a measure.
  */

package/dist/models/Note.js

@@ -1,5 +1,5 @@
-import { Duration, Accidental, DURATION_VALUES, } from './types';
 import { Pitch } from './Pitch';
+import { Accidental, DURATION_VALUES, Duration, } from './types';
 /**
  * Represents a single note or rest in a measure.
  */

package/dist/models/NoteSet.d.ts

@@ -1,5 +1,6 @@
 import { Note, NoteJSON } from './Note';
-import { Duration } from './types';
+import { Pitch } from './Pitch';
+import { Accidental, Arpeggio, Articulation, Bowing, Duration, Dynamic, FretboardDiagram, Glissando, Hairpin, Lyric, NoteheadShape, Ornament, Ottava, Pedal, Slur, StemDirection, Tuplet } from './types';
 export declare class NoteSet {
     readonly notes: Note[];
     constructor(notes: Note[]);
@@ -7,16 +8,16 @@ export declare class NoteSet {
     get isDotted(): boolean;
     get isRest(): boolean;
     get beamGroup(): number | undefined;
-    get tuplet(): import("./types").Tuplet | undefined;
+    get tuplet(): Tuplet | undefined;
     getDurationValue(): number;
     isBeamable(): boolean;
     withDuration(duration: Duration, isDotted?: boolean): NoteSet;
     withBeamGroup(group?: number): NoteSet;
     withNotes(notes: Note[]): NoteSet;
-    withLyrics(lyrics: (string | any)[]): NoteSet;
-    withTuplet(tuplet?: any): NoteSet;
-    withPitch(pitch: any): NoteSet;
-    withAccidental(accidental: any): NoteSet;
+    withLyrics(lyrics: (string | Lyric)[]): NoteSet;
+    withTuplet(tuplet?: Tuplet): NoteSet;
+    withPitch(pitch: Pitch): NoteSet;
+    withAccidental(accidental?: Accidental): NoteSet;
     withRest(isRest: boolean): NoteSet;
     withGrace(isGrace: boolean): NoteSet;
     toggleEnharmonic(): NoteSet;
@@ -26,58 +27,59 @@ export declare class NoteSet {
     withChord(chord?: string): NoteSet;
     withTab(fret: number, string: number): NoteSet;
     withTie(tie: boolean): NoteSet;
-    withSlur(slur?: any): NoteSet;
-    withArticulation(articulation?: any): NoteSet;
-    withOrnament(ornament?: any): NoteSet;
-    withDynamic(dynamic?: any): NoteSet;
-    withHairpin(hairpin?: any): NoteSet;
-    withGlissando(glissando?: any): NoteSet;
-    withArpeggio(arpeggio?: any): NoteSet;
-    withOttava(ottava?: any): NoteSet;
-    withPedal(pedal?: any): NoteSet;
+    withSlur(slur?: Slur): NoteSet;
+    withArticulation(articulation?: Articulation): NoteSet;
+    withOrnament(ornament?: Ornament): NoteSet;
+    withDynamic(dynamic?: Dynamic): NoteSet;
+    withHairpin(hairpin?: Hairpin): NoteSet;
+    withGlissando(glissando?: Glissando): NoteSet;
+    withArpeggio(arpeggio?: Arpeggio): NoteSet;
+    withOttava(ottava?: Ottava): NoteSet;
+    withPedal(pedal?: Pedal): NoteSet;
     withColor(color?: string): NoteSet;
-    withNotehead(notehead: any): NoteSet;
-    withBowing(bowing?: any): NoteSet;
+    withNotehead(notehead?: NoteheadShape): NoteSet;
+    withBowing(bowing?: Bowing): NoteSet;
     withFingering(fingering?: number): NoteSet;
     withHammerOn(type?: 'start' | 'stop'): NoteSet;
     withPullOff(type?: 'start' | 'stop'): NoteSet;
     withPalmMute(type?: 'start' | 'stop'): NoteSet;
     withStringCircled(isStringCircled?: boolean): NoteSet;
-    withStemDirection(dir?: any): NoteSet;
-    withLyric(lyric?: any): NoteSet;
+    withStemDirection(dir?: StemDirection): NoteSet;
+    withLyric(lyric?: string): NoteSet;
     withStaffText(text?: string): NoteSet;
-    withFretboardDiagram(diagram?: any): NoteSet;
-    get pitch(): import("./Pitch").Pitch | undefined;
-    get accidental(): import("./types").Accidental | undefined;
+    withFretboardDiagram(diagram?: FretboardDiagram): NoteSet;
+    get pitch(): Pitch | undefined;
+    get accidental(): Accidental | undefined;
     get tie(): boolean | undefined;
-    get slur(): import("./types").Slur | undefined;
-    get articulation(): import("./types").Articulation | undefined;
-    get ornament(): import("./types").Ornament | undefined;
-    get dynamic(): import("./types").Dynamic | undefined;
-    get hairpin(): import("./types").Hairpin | undefined;
-    get glissando(): import("./types").Glissando | undefined;
-    get arpeggio(): import("./types").Arpeggio | undefined;
-    get ottava(): import("./types").Ottava | undefined;
-    get pedal(): import("./types").Pedal | undefined;
-    get notehead(): import("./types").NoteheadShape | undefined;
+    get slur(): Slur | undefined;
+    get articulations(): Articulation[];
+    get articulation(): Articulation | undefined;
+    get ornament(): Ornament | undefined;
+    get dynamic(): Dynamic | undefined;
+    get hairpin(): Hairpin | undefined;
+    get glissando(): Glissando | undefined;
+    get arpeggio(): Arpeggio | undefined;
+    get ottava(): Ottava | undefined;
+    get pedal(): Pedal | undefined;
+    get notehead(): NoteheadShape | undefined;
     get color(): string | undefined;
     get fret(): number | undefined;
     get string(): number | undefined;
-    get bowing(): import("./types").Bowing | undefined;
+    get bowing(): Bowing | undefined;
     get fingering(): number | undefined;
-    get allLyrics(): import("./types").Lyric[];
-    get lyrics(): (string | import("./types").Lyric)[] | undefined;
+    get allLyrics(): Lyric[];
+    get lyrics(): (string | Lyric)[] | undefined;
     get lyric(): string | undefined;
     get chord(): string | undefined;
-    get fretboardDiagram(): import("./types").FretboardDiagram | undefined;
+    get fretboardDiagram(): FretboardDiagram | undefined;
     get staffText(): string | undefined;
     get hammerOn(): "start" | "stop" | undefined;
     get pullOff(): "start" | "stop" | undefined;
     get palmMute(): "start" | "stop" | undefined;
     get isStringCircled(): boolean | undefined;
-    get stemDirection(): import("./types").StemDirection | undefined;
+    get stemDirection(): StemDirection | undefined;
     toJSON(): NoteSetJSON;
-    static fromJSON(data: any): NoteSet;
+    static fromJSON(data: Partial<NoteSetJSON> | NoteJSON | NoteJSON[]): NoteSet;
 }
 export interface NoteSetJSON {
     notes: NoteJSON[];