musicxml-io 0.12.0 → 0.12.2

package/dist/operations/index.d.ts

@@ -1,2 +1,1234 @@
-import '../types-Cy0veafI.js';
-export { aS as ALL_COLOR_TARGETS, bb as AddArticulationOptions, bk as AddBeamOptions, c9 as AddBowingOptions, ci as AddBreathMarkOptions, cl as AddCaesuraOptions, aX as AddChordOptions, c3 as AddChordSymbolOptions, bT as AddCodaOptions, bd as AddDynamicsOptions, bN as AddEndingOptions, bA as AddFermataOptions, c6 as AddFingeringOptions, bV as AddGraceNoteOptions, c0 as AddHarmonyOptions, bY as AddLyricOptions, bU as AddNavigationOptions, ce as AddOctaveShiftOptions, bC as AddOrnamentOptions, b3 as AddPartOptions, bE as AddPedalOptions, bI as AddRehearsalMarkOptions, bJ as AddRepeatBarlineOptions, bL as AddRepeatOptions, bS as AddSegnoOptions, b9 as AddSlurOptions, cb as AddStringNumberOptions, bv as AddTempoOptions, bG as AddTextDirectionOptions, bH as AddTextOptions, b7 as AddTieOptions, b2 as AddVoiceOptions, by as AddWedgeOptions, bm as AutoBeamOptions, bR as BarStyle, c8 as BowingType, ch as BreathMarkValue, ck as CaesuraValue, bP as ChangeBarlineOptions, bh as ChangeClefOptions, aY as ChangeNoteDurationOptions, cn as ColorTarget, bX as ConvertToGraceOptions, bs as CopyNotesMultiMeasureOptions, bp as CopyNotesOptions, bi as CreateTupletOptions, br as CutNotesOptions, b4 as DuplicatePartOptions, b$ as HarmonyKind, bg as InsertClefChangeOptions, aV as InsertNoteOptions, b1 as LowerAccidentalOptions, bf as ModifyDynamicsOptions, bx as ModifyTempoOptions, b6 as MoveNoteToStaffOptions, bt as MultiMeasureSelection, bo as NoteSelection, cd as OctaveShiftType, aU as OperationErrorCode, aT as OperationResult, bu as PasteNotesMultiMeasureOptions, bq as PasteNotesOptions, b0 as RaiseAccidentalOptions, bc as RemoveArticulationOptions, bl as RemoveBeamOptions, ca as RemoveBowingOptions, cj as RemoveBreathMarkOptions, cm as RemoveCaesuraOptions, c4 as RemoveChordSymbolOptions, be as RemoveDynamicsOptions, bO as RemoveEndingOptions, bB as RemoveFermataOptions, c7 as RemoveFingeringOptions, bW as RemoveGraceNoteOptions, c1 as RemoveHarmonyOptions, bZ as RemoveLyricOptions, aW as RemoveNoteOptions, cg as RemoveOctaveShiftOptions, bD as RemoveOrnamentOptions, bF as RemovePedalOptions, bK as RemoveRepeatBarlineOptions, bM as RemoveRepeatOptions, ba as RemoveSlurOptions, cc as RemoveStringNumberOptions, bw as RemoveTempoOptions, b8 as RemoveTieOptions, bj as RemoveTupletOptions, bz as RemoveWedgeOptions, bQ as SetBarlineOptions, bn as SetBeamingOptions, co as SetColorOptions, a_ as SetNotePitchBySemitoneOptions, aZ as SetNotePitchOptions, b5 as SetStavesOptions, a$ as ShiftNotePitchOptions, cf as StopOctaveShiftOptions, c5 as UpdateChordSymbolOptions, c2 as UpdateHarmonyOptions, b_ as UpdateLyricOptions, cK as ValidationError, J as addArticulation, S as addBeam, aF as addBowing, aM as addBreathMark, aO as addCaesura, a as addChord, h as addChordNote, o as addChordNoteChecked, aA as addChordSymbol, am as addCoda, an as addDaCapo, ao as addDalSegno, L as addDynamics, ah as addEnding, a4 as addFermata, ap as addFine, aD as addFingering, ar as addGraceNote, ax as addHarmony, au as addLyric, f as addNote, k as addNoteChecked, aJ as addOctaveShift, a6 as addOrnament, w as addPart, a8 as addPedal, ac as addRehearsalMark, af as addRepeat, ad as addRepeatBarline, al as addSegno, H as addSlur, aH as addStringNumber, $ as addTempo, ab as addText, aa as addTextDirection, F as addTie, aq as addToCoda, v as addVoice, a2 as addWedge, U as autoBeam, aj as changeBarline, P as changeClef, B as changeKey, d as changeNoteDuration, C as changeTime, aR as clearColors, at as convertToGrace, W as copyNotes, Z as copyNotesMultiMeasure, Q as createTuplet, Y as cutNotes, E as deleteMeasure, g as deleteNote, n as deleteNoteChecked, y as duplicatePart, O as insertClefChange, D as insertMeasure, i as insertNote, l as lowerAccidental, N as modifyDynamics, j as modifyNoteDuration, q as modifyNoteDurationChecked, m as modifyNotePitch, p as modifyNotePitchChecked, a1 as modifyTempo, A as moveNoteToStaff, X as pasteNotes, _ as pasteNotesMultiMeasure, e as raiseAccidental, K as removeArticulation, T as removeBeam, aG as removeBowing, aN as removeBreathMark, aP as removeCaesura, aB as removeChordSymbol, M as removeDynamics, ai as removeEnding, a5 as removeFermata, aE as removeFingering, as as removeGraceNote, ay as removeHarmony, av as removeLyric, r as removeNote, aL as removeOctaveShift, a7 as removeOrnament, x as removePart, a9 as removePedal, ag as removeRepeat, ae as removeRepeatBarline, I as removeSlur, aI as removeStringNumber, a0 as removeTempo, G as removeTie, R as removeTuplet, a3 as removeWedge, ak as setBarline, V as setBeaming, aQ as setColor, s as setNotePitch, b as setNotePitchBySemitone, z as setStaves, c as shiftNotePitch, aK as stopOctaveShift, t as transpose, u as transposeChecked, aC as updateChordSymbol, az as updateHarmony, aw as updateLyric } from '../index-CbUtBHLD.js';
+import { S as Score, g as Pitch, N as NoteEntry, v as TimeSignature, K as KeySignature, w as Clef, ao as ArticulationType, p as DynamicsValue, ap as OrnamentType, h as NoteType, C as Color } from '../types-B-RGHY0c.js';
+import { t as ValidationError } from '../index-DNA970t1.js';
+
+/**
+ * Operation result type - success with data or failure with errors
+ */
+type OperationResult<T> = {
+    success: true;
+    data: T;
+    warnings?: ValidationError[];
+} | {
+    success: false;
+    errors: ValidationError[];
+};
+type OperationErrorCode = 'NOTE_CONFLICT' | 'EXCEEDS_MEASURE' | 'INVALID_POSITION' | 'NOTE_NOT_FOUND' | 'PART_NOT_FOUND' | 'MEASURE_NOT_FOUND' | 'INVALID_DURATION' | 'INVALID_STAFF' | 'DUPLICATE_PART_ID' | 'TIE_ALREADY_EXISTS' | 'TIE_NOT_FOUND' | 'TIE_PITCH_MISMATCH' | 'TIE_INVALID_TARGET' | 'SLUR_ALREADY_EXISTS' | 'SLUR_NOT_FOUND' | 'ARTICULATION_ALREADY_EXISTS' | 'ARTICULATION_NOT_FOUND' | 'DYNAMICS_ALREADY_EXISTS' | 'DYNAMICS_NOT_FOUND' | 'INVALID_CLEF' | 'ACCIDENTAL_OUT_OF_BOUNDS' | 'BARLINE_NOT_FOUND' | 'BARLINE_ALREADY_EXISTS' | 'ENDING_NOT_FOUND' | 'ENDING_ALREADY_EXISTS' | 'REPEAT_NOT_FOUND' | 'REPEAT_ALREADY_EXISTS' | 'GRACE_NOTE_NOT_FOUND' | 'INVALID_GRACE_NOTE' | 'LYRIC_NOT_FOUND' | 'LYRIC_ALREADY_EXISTS' | 'HARMONY_NOT_FOUND' | 'HARMONY_ALREADY_EXISTS' | 'INVALID_HARMONY' | 'TEMPO_NOT_FOUND' | 'INVALID_RANGE' | 'WEDGE_NOT_FOUND' | 'FERMATA_ALREADY_EXISTS' | 'FERMATA_NOT_FOUND' | 'ORNAMENT_ALREADY_EXISTS' | 'ORNAMENT_NOT_FOUND' | 'PEDAL_NOT_FOUND' | 'INVALID_TEXT';
+interface InsertNoteOptions {
+    partIndex: number;
+    measureIndex: number;
+    voice: string;
+    staff?: number;
+    position: number;
+    pitch: Pitch;
+    duration: number;
+    noteType?: NoteEntry['noteType'];
+    dots?: number;
+}
+/**
+ * Insert a note at the specified position in a voice.
+ * - If the position has a rest, replaces it with the note
+ * - If there's a conflicting note, returns NOTE_CONFLICT error
+ * - If the note exceeds measure duration, returns EXCEEDS_MEASURE error
+ */
+declare function insertNote(score: Score, options: InsertNoteOptions): OperationResult<Score>;
+interface RemoveNoteOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}
+/**
+ * Remove a note and replace with rest
+ */
+declare function removeNote(score: Score, options: RemoveNoteOptions): OperationResult<Score>;
+interface AddChordOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    pitch: Pitch;
+}
+/**
+ * Add a chord note to an existing note
+ */
+declare function addChord(score: Score, options: AddChordOptions): OperationResult<Score>;
+interface ChangeNoteDurationOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    newDuration: number;
+    noteType?: NoteEntry['noteType'];
+    dots?: number;
+}
+/**
+ * Change note duration with proper handling of following notes
+ * - If longer: consumes following rests/notes, returns error if would overwrite notes
+ * - If shorter: fills remainder with rest
+ */
+declare function changeNoteDuration(score: Score, options: ChangeNoteDurationOptions): OperationResult<Score>;
+interface SetNotePitchOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    pitch: Pitch;
+}
+/**
+ * Set note pitch (simple pitch change, no validation needed)
+ */
+declare function setNotePitch(score: Score, options: SetNotePitchOptions): OperationResult<Score>;
+interface SetNotePitchBySemitoneOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    /** MIDI-like semitone value (C4 = 48, C#4 = 49, etc.) */
+    semitone: number;
+    /** Prefer sharp spelling over flat (defaults to key signature preference) */
+    preferSharp?: boolean;
+}
+/**
+ * Set note pitch by semitone value, considering key signature and accidentals.
+ * Automatically determines the appropriate enharmonic spelling and sets the accidental if needed.
+ */
+declare function setNotePitchBySemitone(score: Score, options: SetNotePitchBySemitoneOptions): OperationResult<Score>;
+interface ShiftNotePitchOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    /** Number of semitones to shift (positive = up, negative = down) */
+    semitones: number;
+    /** Prefer sharp spelling over flat (defaults to key signature preference) */
+    preferSharp?: boolean;
+}
+/**
+ * Shift note pitch by a number of semitones, considering key signature and accidentals.
+ * Automatically determines the appropriate enharmonic spelling and sets the accidental if needed.
+ */
+declare function shiftNotePitch(score: Score, options: ShiftNotePitchOptions): OperationResult<Score>;
+interface RaiseAccidentalOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}
+/**
+ * Raise the accidental of a note by one step.
+ * C → C#, C# → C##, Db → D, etc.
+ * Keeps the note's step (letter name) and increments alter by 1.
+ * Returns error if alter would exceed +2.
+ */
+declare function raiseAccidental(score: Score, options: RaiseAccidentalOptions): OperationResult<Score>;
+interface LowerAccidentalOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}
+/**
+ * Lower the accidental of a note by one step.
+ * C# → C, C## → C#, D → Db, Db → Dbb, etc.
+ * Keeps the note's step (letter name) and decrements alter by 1.
+ * Returns error if alter would go below -2.
+ */
+declare function lowerAccidental(score: Score, options: LowerAccidentalOptions): OperationResult<Score>;
+interface AddVoiceOptions {
+    partIndex: number;
+    measureIndex: number;
+    voice: string;
+    staff?: number;
+}
+/**
+ * Add a new voice to a measure, filled with a whole-measure rest
+ */
+declare function addVoice(score: Score, options: AddVoiceOptions): OperationResult<Score>;
+/**
+ * Transpose all notes in the score
+ */
+declare function transpose(score: Score, semitones: number): OperationResult<Score>;
+interface AddPartOptions {
+    id: string;
+    name?: string;
+    abbreviation?: string;
+    insertIndex?: number;
+    time?: TimeSignature;
+    key?: KeySignature;
+    clef?: Clef;
+    divisions?: number;
+}
+declare function addPart(score: Score, options: AddPartOptions): OperationResult<Score>;
+declare function removePart(score: Score, partId: string): OperationResult<Score>;
+interface DuplicatePartOptions {
+    sourcePartId: string;
+    newPartId: string;
+    newPartName?: string;
+}
+declare function duplicatePart(score: Score, options: DuplicatePartOptions): OperationResult<Score>;
+interface SetStavesOptions {
+    partIndex: number;
+    staves: number;
+    clefs?: Clef[];
+    fromMeasure?: number;
+}
+declare function setStaves(score: Score, options: SetStavesOptions): OperationResult<Score>;
+interface MoveNoteToStaffOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    targetStaff: number;
+}
+declare function moveNoteToStaff(score: Score, options: MoveNoteToStaffOptions): OperationResult<Score>;
+declare function changeKey(score: Score, key: KeySignature, options: {
+    fromMeasure: string | number;
+}): Score;
+declare function changeTime(score: Score, time: TimeSignature, options: {
+    fromMeasure: string | number;
+}): Score;
+declare function insertMeasure(score: Score, options: {
+    afterMeasure: string | number;
+    copyAttributes?: boolean;
+}): Score;
+declare function deleteMeasure(score: Score, measureNumber: string | number): Score;
+interface AddTieOptions {
+    partIndex: number;
+    startMeasureIndex: number;
+    startNoteIndex: number;
+    endMeasureIndex: number;
+    endNoteIndex: number;
+}
+/**
+ * Add a tie between two notes.
+ * The notes must have the same pitch.
+ * Adds tie start to the first note and tie stop to the second note.
+ */
+declare function addTie(score: Score, options: AddTieOptions): OperationResult<Score>;
+interface RemoveTieOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}
+/**
+ * Remove a tie from a note (removes both start and stop if the note is part of a tie)
+ */
+declare function removeTie(score: Score, options: RemoveTieOptions): OperationResult<Score>;
+interface AddSlurOptions {
+    partIndex: number;
+    startMeasureIndex: number;
+    startNoteIndex: number;
+    endMeasureIndex: number;
+    endNoteIndex: number;
+    number?: number;
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a slur between two notes
+ */
+declare function addSlur(score: Score, options: AddSlurOptions): OperationResult<Score>;
+interface RemoveSlurOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    number?: number;
+}
+/**
+ * Remove a slur from a note
+ */
+declare function removeSlur(score: Score, options: RemoveSlurOptions): OperationResult<Score>;
+interface AddArticulationOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    articulation: ArticulationType;
+    placement?: 'above' | 'below';
+}
+/**
+ * Add an articulation to a note
+ */
+declare function addArticulation(score: Score, options: AddArticulationOptions): OperationResult<Score>;
+interface RemoveArticulationOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    articulation: ArticulationType;
+}
+/**
+ * Remove an articulation from a note
+ */
+declare function removeArticulation(score: Score, options: RemoveArticulationOptions): OperationResult<Score>;
+interface AddDynamicsOptions {
+    partIndex: number;
+    measureIndex: number;
+    position: number;
+    dynamics: DynamicsValue;
+    staff?: number;
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a dynamics marking at a specific position in a measure
+ */
+declare function addDynamics(score: Score, options: AddDynamicsOptions): OperationResult<Score>;
+interface RemoveDynamicsOptions {
+    partIndex: number;
+    measureIndex: number;
+    directionIndex: number;
+}
+/**
+ * Remove a dynamics direction from a measure
+ */
+declare function removeDynamics(score: Score, options: RemoveDynamicsOptions): OperationResult<Score>;
+interface ModifyDynamicsOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Index of the dynamics direction to modify (among dynamics directions in the measure) */
+    directionIndex: number;
+    /** New dynamics value */
+    dynamics: DynamicsValue;
+    /** New placement (optional) */
+    placement?: 'above' | 'below';
+}
+/**
+ * Modify an existing dynamics marking in a measure
+ */
+declare function modifyDynamics(score: Score, options: ModifyDynamicsOptions): OperationResult<Score>;
+interface InsertClefChangeOptions {
+    partIndex: number;
+    measureIndex: number;
+    position: number;
+    clef: Clef;
+}
+/**
+ * Insert a clef change at a specific position within a measure
+ */
+declare function insertClefChange(score: Score, options: InsertClefChangeOptions): OperationResult<Score>;
+/** @deprecated Use insertNote instead */
+declare const addNote: (score: Score, options: {
+    partIndex: number;
+    measureIndex: number;
+    staff?: number;
+    voice: string;
+    position: number;
+    note: Omit<NoteEntry, "type" | "voice" | "staff">;
+}) => Score;
+/** @deprecated Use removeNote instead */
+declare const deleteNote: (score: Score, options: {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}) => Score;
+/** @deprecated Use addChord instead */
+declare const addChordNote: (score: Score, options: {
+    partIndex: number;
+    measureIndex: number;
+    afterNoteIndex: number;
+    pitch: Pitch;
+}) => Score;
+/** @deprecated Use setNotePitch instead */
+declare const modifyNotePitch: (score: Score, options: {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    pitch: Pitch;
+}) => Score;
+/** @deprecated Use changeNoteDuration instead */
+declare const modifyNoteDuration: (score: Score, options: {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    duration: number;
+    noteType?: NoteEntry["noteType"];
+    dots?: number;
+}) => Score;
+/** @deprecated Use insertNote instead */
+declare const addNoteChecked: (score: Score, options: {
+    partIndex: number;
+    measureIndex: number;
+    staff?: number;
+    voice: string;
+    position: number;
+    note: Omit<NoteEntry, "type" | "voice" | "staff">;
+}) => OperationResult<Score>;
+/** @deprecated Use removeNote instead */
+declare const deleteNoteChecked: typeof removeNote;
+/** @deprecated Use addChord instead */
+declare const addChordNoteChecked: (score: Score, options: {
+    partIndex: number;
+    measureIndex: number;
+    afterNoteIndex: number;
+    pitch: Pitch;
+}) => OperationResult<Score>;
+/** @deprecated Use setNotePitch instead */
+declare const modifyNotePitchChecked: typeof setNotePitch;
+/** @deprecated Use changeNoteDuration instead */
+declare const modifyNoteDurationChecked: (score: Score, options: {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    duration: number;
+    noteType?: NoteEntry["noteType"];
+    dots?: number;
+}) => OperationResult<Score>;
+/** @deprecated Use transpose instead */
+declare const transposeChecked: typeof transpose;
+interface CreateTupletOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Starting note index (0-based, counting pitched notes only) */
+    startNoteIndex: number;
+    /** Number of notes to include in the tuplet */
+    noteCount: number;
+    /** Actual notes in the time of normal notes (e.g., 3 for triplet) */
+    actualNotes: number;
+    /** Normal notes (e.g., 2 for triplet) */
+    normalNotes: number;
+    /** Show bracket (default: true) */
+    bracket?: boolean;
+    /** Show number display (default: 'actual') */
+    showNumber?: 'actual' | 'both' | 'none';
+}
+/**
+ * Create a tuplet from consecutive notes.
+ * A tuplet fits `actualNotes` notes in the time of `normalNotes` (e.g., 3 in the time of 2 for triplets).
+ *
+ * @example
+ * // Create a triplet from 3 eighth notes (3 in the time of 2)
+ * createTuplet(score, {
+ *   partIndex: 0,
+ *   measureIndex: 0,
+ *   startNoteIndex: 0,
+ *   noteCount: 3,
+ *   actualNotes: 3,
+ *   normalNotes: 2,
+ * })
+ */
+declare function createTuplet(score: Score, options: CreateTupletOptions): OperationResult<Score>;
+interface RemoveTupletOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Note index of any note within the tuplet */
+    noteIndex: number;
+}
+/**
+ * Remove tuplet from notes.
+ * Finds the tuplet containing the specified note and removes all tuplet information.
+ */
+declare function removeTuplet(score: Score, options: RemoveTupletOptions): OperationResult<Score>;
+interface AddBeamOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Starting note index */
+    startNoteIndex: number;
+    /** Number of notes to beam together */
+    noteCount: number;
+    /** Beam level (1 = eighth notes, 2 = sixteenth notes, etc.) */
+    beamLevel?: number;
+}
+/**
+ * Add beaming to consecutive notes.
+ * Notes must be in the same voice and should be eighth notes or shorter.
+ */
+declare function addBeam(score: Score, options: AddBeamOptions): OperationResult<Score>;
+interface RemoveBeamOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Note index of any note within the beam group */
+    noteIndex: number;
+    /** Beam level to remove (default: all levels) */
+    beamLevel?: number;
+}
+/**
+ * Remove beaming from notes.
+ */
+declare function removeBeam(score: Score, options: RemoveBeamOptions): OperationResult<Score>;
+interface AutoBeamOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Optional voice filter */
+    voice?: string;
+    /** Group by beat (default: true) */
+    groupByBeat?: boolean;
+}
+/**
+ * Automatically beam notes based on time signature and beat groupings.
+ * Groups eighth notes and shorter notes by beat.
+ */
+declare function autoBeam(score: Score, options: AutoBeamOptions): OperationResult<Score>;
+/**
+ * Selection represents copied content that can be pasted
+ */
+interface NoteSelection {
+    /** Source information */
+    source: {
+        partIndex: number;
+        measureIndex: number;
+        startPosition: number;
+        endPosition: number;
+        voice: string;
+        staff?: number;
+    };
+    /** Copied notes with their relative positions */
+    notes: Array<{
+        /** Relative position from selection start */
+        relativePosition: number;
+        /** Note data (deep cloned) */
+        note: NoteEntry;
+    }>;
+    /** Total duration of the selection */
+    duration: number;
+}
+interface CopyNotesOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Start position in the measure (in divisions) */
+    startPosition: number;
+    /** End position in the measure (in divisions) */
+    endPosition: number;
+    /** Voice to copy from */
+    voice: string;
+    /** Staff to copy from (optional) */
+    staff?: number;
+}
+/**
+ * Copy notes from a range in a measure.
+ * Returns a NoteSelection that can be used with pasteNotes.
+ */
+declare function copyNotes(score: Score, options: CopyNotesOptions): OperationResult<NoteSelection>;
+interface PasteNotesOptions {
+    /** Selection to paste */
+    selection: NoteSelection;
+    /** Target part index */
+    partIndex: number;
+    /** Target measure index */
+    measureIndex: number;
+    /** Target position in the measure */
+    position: number;
+    /** Target voice (defaults to original voice) */
+    voice?: string;
+    /** Target staff (defaults to original staff) */
+    staff?: number;
+    /** Clear existing notes in the paste range (default: true) */
+    overwrite?: boolean;
+}
+/**
+ * Paste notes from a NoteSelection to a target position.
+ */
+declare function pasteNotes(score: Score, options: PasteNotesOptions): OperationResult<Score>;
+type CutNotesOptions = CopyNotesOptions;
+/**
+ * Cut notes from a range (copy and delete).
+ * Returns both the selection and the modified score.
+ */
+declare function cutNotes(score: Score, options: CutNotesOptions): OperationResult<{
+    score: Score;
+    selection: NoteSelection;
+}>;
+interface CopyNotesMultiMeasureOptions {
+    partIndex: number;
+    /** Starting measure index */
+    startMeasureIndex: number;
+    /** Ending measure index (inclusive) */
+    endMeasureIndex: number;
+    /** Voice to copy from */
+    voice: string;
+    /** Staff to copy from (optional) */
+    staff?: number;
+}
+/**
+ * Selection for multiple measures
+ */
+interface MultiMeasureSelection {
+    source: {
+        partIndex: number;
+        startMeasureIndex: number;
+        endMeasureIndex: number;
+        voice: string;
+        staff?: number;
+    };
+    /** Notes grouped by measure offset */
+    measures: Array<{
+        measureOffset: number;
+        notes: Array<{
+            relativePosition: number;
+            note: NoteEntry;
+        }>;
+    }>;
+}
+/**
+ * Copy notes across multiple measures.
+ */
+declare function copyNotesMultiMeasure(score: Score, options: CopyNotesMultiMeasureOptions): OperationResult<MultiMeasureSelection>;
+interface PasteNotesMultiMeasureOptions {
+    selection: MultiMeasureSelection;
+    partIndex: number;
+    /** Target starting measure index */
+    startMeasureIndex: number;
+    /** Target voice (defaults to original voice) */
+    voice?: string;
+    /** Target staff (defaults to original staff) */
+    staff?: number;
+    /** Clear existing notes in paste measures (default: true) */
+    overwrite?: boolean;
+}
+/**
+ * Paste notes across multiple measures.
+ */
+declare function pasteNotesMultiMeasure(score: Score, options: PasteNotesMultiMeasureOptions): OperationResult<Score>;
+interface AddTempoOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Position in divisions within the measure */
+    position: number;
+    /** Tempo in BPM */
+    bpm: number;
+    /** Beat unit (e.g., 'quarter', 'half', 'eighth') */
+    beatUnit?: 'whole' | 'half' | 'quarter' | 'eighth' | '16th';
+    /** Whether beat unit has a dot */
+    beatUnitDot?: boolean;
+    /** Text description (e.g., 'Allegro', 'Andante') */
+    text?: string;
+    /** Placement (above/below staff) */
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a tempo marking to a measure.
+ */
+declare function addTempo(score: Score, options: AddTempoOptions): OperationResult<Score>;
+interface RemoveTempoOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Index of the direction to remove (among tempo directions) */
+    directionIndex?: number;
+}
+/**
+ * Remove a tempo marking from a measure.
+ */
+declare function removeTempo(score: Score, options: RemoveTempoOptions): OperationResult<Score>;
+interface ModifyTempoOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Index of the tempo direction to modify (among tempo directions in the measure) */
+    directionIndex?: number;
+    /** New BPM value */
+    bpm?: number;
+    /** New beat unit */
+    beatUnit?: 'whole' | 'half' | 'quarter' | 'eighth' | '16th' | '32nd' | '64th';
+    /** Beat unit dot */
+    beatUnitDot?: boolean;
+    /** New tempo text (e.g., 'Allegro') */
+    text?: string;
+    /** Placement */
+    placement?: 'above' | 'below';
+}
+/**
+ * Modify an existing tempo marking in a measure
+ */
+declare function modifyTempo(score: Score, options: ModifyTempoOptions): OperationResult<Score>;
+interface AddWedgeOptions {
+    partIndex: number;
+    /** Starting measure index */
+    startMeasureIndex: number;
+    /** Starting position in divisions */
+    startPosition: number;
+    /** Ending measure index */
+    endMeasureIndex: number;
+    /** Ending position in divisions */
+    endPosition: number;
+    /** Wedge type */
+    type: 'crescendo' | 'diminuendo';
+    /** Staff number (for multi-staff parts) */
+    staff?: number;
+    /** Placement (above/below) */
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a wedge (crescendo or diminuendo) spanning one or more measures.
+ */
+declare function addWedge(score: Score, options: AddWedgeOptions): OperationResult<Score>;
+interface RemoveWedgeOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Index of the wedge start direction to remove */
+    directionIndex?: number;
+}
+/**
+ * Remove a wedge (and its corresponding stop).
+ */
+declare function removeWedge(score: Score, options: RemoveWedgeOptions): OperationResult<Score>;
+interface AddFermataOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    /** Fermata shape */
+    shape?: 'normal' | 'angled' | 'square' | 'double-angled' | 'double-square' | 'double-dot' | 'half-curve' | 'curlew';
+    /** Fermata type (upright or inverted) */
+    fermataType?: 'upright' | 'inverted';
+    /** Placement */
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a fermata to a note.
+ */
+declare function addFermata(score: Score, options: AddFermataOptions): OperationResult<Score>;
+interface RemoveFermataOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}
+/**
+ * Remove a fermata from a note.
+ */
+declare function removeFermata(score: Score, options: RemoveFermataOptions): OperationResult<Score>;
+interface AddOrnamentOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    /** Ornament type */
+    ornament: OrnamentType;
+    /** Placement */
+    placement?: 'above' | 'below';
+    /** Accidental mark for the ornament */
+    accidentalMark?: 'sharp' | 'flat' | 'natural' | 'double-sharp' | 'flat-flat';
+}
+/**
+ * Add an ornament (trill, mordent, turn, etc.) to a note.
+ */
+declare function addOrnament(score: Score, options: AddOrnamentOptions): OperationResult<Score>;
+interface RemoveOrnamentOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    /** Specific ornament to remove (removes first ornament if not specified) */
+    ornament?: OrnamentType;
+}
+/**
+ * Remove an ornament from a note.
+ */
+declare function removeOrnament(score: Score, options: RemoveOrnamentOptions): OperationResult<Score>;
+interface AddPedalOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Position in divisions */
+    position: number;
+    /** Pedal type */
+    pedalType: 'start' | 'stop' | 'change' | 'continue';
+    /** Show as line or Ped/star symbols */
+    line?: boolean;
+    /** Placement */
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a pedal marking.
+ */
+declare function addPedal(score: Score, options: AddPedalOptions): OperationResult<Score>;
+interface RemovePedalOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Index of the pedal direction to remove (among pedal directions) */
+    directionIndex?: number;
+}
+/**
+ * Remove a pedal marking.
+ */
+declare function removePedal(score: Score, options: RemovePedalOptions): OperationResult<Score>;
+interface AddTextDirectionOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Position in divisions */
+    position: number;
+    /** Text content */
+    text: string;
+    /** Font style */
+    fontStyle?: 'normal' | 'italic';
+    /** Font weight */
+    fontWeight?: 'normal' | 'bold';
+    /** Placement */
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a text direction (expression text, performance instruction).
+ */
+declare function addTextDirection(score: Score, options: AddTextDirectionOptions): OperationResult<Score>;
+interface AddRehearsalMarkOptions {
+    partIndex: number;
+    measureIndex: number;
+    /** Rehearsal mark text (e.g., 'A', 'B', '1', '2') */
+    text: string;
+    /** Enclosure type */
+    enclosure?: 'square' | 'circle' | 'oval' | 'rectangle' | 'diamond' | 'triangle' | 'pentagon' | 'hexagon' | 'none';
+}
+/**
+ * Add a rehearsal mark to a measure.
+ */
+declare function addRehearsalMark(score: Score, options: AddRehearsalMarkOptions): OperationResult<Score>;
+type BarStyle = 'regular' | 'dotted' | 'dashed' | 'heavy' | 'light-light' | 'light-heavy' | 'heavy-light' | 'heavy-heavy' | 'tick' | 'short' | 'none';
+interface AddRepeatBarlineOptions {
+    partIndex: number;
+    measureIndex: number;
+    direction: 'forward' | 'backward';
+    times?: number;
+}
+/**
+ * Add a repeat barline to a measure.
+ * Forward repeats go on the left, backward repeats go on the right.
+ * This operation applies to all parts at the specified measure index.
+ */
+declare function addRepeatBarline(score: Score, options: AddRepeatBarlineOptions): OperationResult<Score>;
+interface RemoveRepeatBarlineOptions {
+    partIndex: number;
+    measureIndex: number;
+    location: 'left' | 'right';
+}
+/**
+ * Remove a repeat barline from a measure.
+ * This operation applies to all parts at the specified measure index.
+ */
+declare function removeRepeatBarline(score: Score, options: RemoveRepeatBarlineOptions): OperationResult<Score>;
+interface AddEndingOptions {
+    partIndex: number;
+    measureIndex: number;
+    number: string;
+    type: 'start' | 'stop' | 'discontinue';
+}
+/**
+ * Add an ending (volta bracket) to a measure.
+ * Start endings go on the left barline, stop/discontinue on the right.
+ * This operation applies to all parts at the specified measure index.
+ */
+declare function addEnding(score: Score, options: AddEndingOptions): OperationResult<Score>;
+interface RemoveEndingOptions {
+    partIndex: number;
+    measureIndex: number;
+    location: 'left' | 'right';
+}
+/**
+ * Remove an ending (volta bracket) from a measure.
+ * This operation applies to all parts at the specified measure index.
+ */
+declare function removeEnding(score: Score, options: RemoveEndingOptions): OperationResult<Score>;
+interface ChangeBarlineOptions {
+    partIndex: number;
+    measureIndex: number;
+    location: 'left' | 'right' | 'middle';
+    barStyle: BarStyle;
+}
+/**
+ * Change the barline style at a specific location in a measure.
+ * This operation applies to all parts at the specified measure index.
+ */
+declare function changeBarline(score: Score, options: ChangeBarlineOptions): OperationResult<Score>;
+interface AddSegnoOptions {
+    partIndex: number;
+    measureIndex: number;
+    position?: number;
+}
+/**
+ * Add a segno sign to a measure.
+ */
+declare function addSegno(score: Score, options: AddSegnoOptions): OperationResult<Score>;
+interface AddCodaOptions {
+    partIndex: number;
+    measureIndex: number;
+    position?: number;
+}
+/**
+ * Add a coda sign to a measure.
+ */
+declare function addCoda(score: Score, options: AddCodaOptions): OperationResult<Score>;
+interface AddNavigationOptions {
+    partIndex: number;
+    measureIndex: number;
+    position?: number;
+}
+/**
+ * Add a D.C. (Da Capo) marking to a measure.
+ * This adds both the text direction and the sound element.
+ */
+declare function addDaCapo(score: Score, options: AddNavigationOptions): OperationResult<Score>;
+/**
+ * Add a D.S. (Dal Segno) marking to a measure.
+ */
+declare function addDalSegno(score: Score, options: AddNavigationOptions): OperationResult<Score>;
+/**
+ * Add a Fine marking to a measure.
+ */
+declare function addFine(score: Score, options: AddNavigationOptions): OperationResult<Score>;
+/**
+ * Add a To Coda marking to a measure.
+ */
+declare function addToCoda(score: Score, options: AddNavigationOptions): OperationResult<Score>;
+interface AddGraceNoteOptions {
+    partIndex: number;
+    measureIndex: number;
+    targetNoteIndex: number;
+    pitch: Pitch;
+    noteType?: NoteType;
+    slash?: boolean;
+    voice?: string;
+    staff?: number;
+}
+/**
+ * Add a grace note before a target note.
+ * Grace notes do not have duration in MusicXML.
+ */
+declare function addGraceNote(score: Score, options: AddGraceNoteOptions): OperationResult<Score>;
+interface RemoveGraceNoteOptions {
+    partIndex: number;
+    measureIndex: number;
+    graceNoteIndex: number;
+}
+/**
+ * Remove a grace note from a measure.
+ */
+declare function removeGraceNote(score: Score, options: RemoveGraceNoteOptions): OperationResult<Score>;
+interface ConvertToGraceOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    slash?: boolean;
+}
+/**
+ * Convert a regular note to a grace note.
+ * The note's duration will be removed.
+ */
+declare function convertToGrace(score: Score, options: ConvertToGraceOptions): OperationResult<Score>;
+interface AddLyricOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    text: string;
+    syllabic?: 'single' | 'begin' | 'middle' | 'end';
+    verse?: number;
+    extend?: boolean;
+}
+/**
+ * Add a lyric to a note.
+ */
+declare function addLyric(score: Score, options: AddLyricOptions): OperationResult<Score>;
+interface RemoveLyricOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    verse?: number;
+}
+/**
+ * Remove a lyric from a note.
+ */
+declare function removeLyric(score: Score, options: RemoveLyricOptions): OperationResult<Score>;
+interface UpdateLyricOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    verse?: number;
+    text?: string;
+    syllabic?: 'single' | 'begin' | 'middle' | 'end';
+    extend?: boolean;
+}
+/**
+ * Update an existing lyric on a note.
+ */
+declare function updateLyric(score: Score, options: UpdateLyricOptions): OperationResult<Score>;
+type HarmonyKind = 'major' | 'minor' | 'augmented' | 'diminished' | 'dominant' | 'major-seventh' | 'minor-seventh' | 'diminished-seventh' | 'augmented-seventh' | 'half-diminished' | 'major-minor' | 'major-sixth' | 'minor-sixth' | 'dominant-ninth' | 'major-ninth' | 'minor-ninth' | 'dominant-11th' | 'major-11th' | 'minor-11th' | 'dominant-13th' | 'major-13th' | 'minor-13th' | 'suspended-second' | 'suspended-fourth' | 'Neapolitan' | 'Italian' | 'French' | 'German' | 'pedal' | 'power' | 'Tristan' | 'other' | 'none';
+interface AddHarmonyOptions {
+    partIndex: number;
+    measureIndex: number;
+    position: number;
+    root: {
+        step: string;
+        alter?: number;
+    };
+    kind: HarmonyKind;
+    kindText?: string;
+    bass?: {
+        step: string;
+        alter?: number;
+    };
+    degrees?: {
+        value: number;
+        alter?: number;
+        type: 'add' | 'alter' | 'subtract';
+    }[];
+    staff?: number;
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a harmony (chord symbol) to a measure.
+ */
+declare function addHarmony(score: Score, options: AddHarmonyOptions): OperationResult<Score>;
+interface RemoveHarmonyOptions {
+    partIndex: number;
+    measureIndex: number;
+    harmonyIndex: number;
+}
+/**
+ * Remove a harmony from a measure.
+ */
+declare function removeHarmony(score: Score, options: RemoveHarmonyOptions): OperationResult<Score>;
+interface UpdateHarmonyOptions {
+    partIndex: number;
+    measureIndex: number;
+    harmonyIndex: number;
+    root?: {
+        step: string;
+        alter?: number;
+    };
+    kind?: HarmonyKind;
+    kindText?: string;
+    bass?: {
+        step: string;
+        alter?: number;
+    } | null;
+    degrees?: {
+        value: number;
+        alter?: number;
+        type: 'add' | 'alter' | 'subtract';
+    }[] | null;
+}
+/**
+ * Update an existing harmony in a measure.
+ */
+declare function updateHarmony(score: Score, options: UpdateHarmonyOptions): OperationResult<Score>;
+interface AddFingeringOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    fingering: string;
+    substitution?: boolean;
+    alternate?: boolean;
+    placement?: 'above' | 'below';
+}
+/**
+ * Add fingering notation to a note.
+ * Fingering is typically indicated 1,2,3,4,5.
+ */
+declare function addFingering(score: Score, options: AddFingeringOptions): OperationResult<Score>;
+interface RemoveFingeringOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}
+/**
+ * Remove fingering notation from a note.
+ */
+declare function removeFingering(score: Score, options: RemoveFingeringOptions): OperationResult<Score>;
+type BowingType = 'up-bow' | 'down-bow';
+interface AddBowingOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    bowingType: BowingType;
+    placement?: 'above' | 'below';
+}
+/**
+ * Add bowing notation (up-bow or down-bow) to a note.
+ * Used for bowed string instruments.
+ */
+declare function addBowing(score: Score, options: AddBowingOptions): OperationResult<Score>;
+interface RemoveBowingOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    bowingType?: BowingType;
+}
+/**
+ * Remove bowing notation from a note.
+ */
+declare function removeBowing(score: Score, options: RemoveBowingOptions): OperationResult<Score>;
+interface AddStringNumberOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    stringNumber: number;
+    placement?: 'above' | 'below';
+}
+/**
+ * Add string number notation to a note.
+ * Used for fretted instruments and bowed strings.
+ */
+declare function addStringNumber(score: Score, options: AddStringNumberOptions): OperationResult<Score>;
+interface RemoveStringNumberOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}
+/**
+ * Remove string number notation from a note.
+ */
+declare function removeStringNumber(score: Score, options: RemoveStringNumberOptions): OperationResult<Score>;
+type OctaveShiftType = 'up' | 'down';
+interface AddOctaveShiftOptions {
+    partIndex: number;
+    measureIndex: number;
+    position: number;
+    shiftType: OctaveShiftType;
+    size?: number;
+}
+/**
+ * Add an octave shift (8va/8vb) direction.
+ * Type 'down' means notes appear higher than sounding (8va).
+ * Type 'up' means notes appear lower than sounding (8vb).
+ */
+declare function addOctaveShift(score: Score, options: AddOctaveShiftOptions): OperationResult<Score>;
+interface StopOctaveShiftOptions {
+    partIndex: number;
+    measureIndex: number;
+    position: number;
+    size?: number;
+}
+/**
+ * Stop an octave shift at the specified position.
+ */
+declare function stopOctaveShift(score: Score, options: StopOctaveShiftOptions): OperationResult<Score>;
+interface RemoveOctaveShiftOptions {
+    partIndex: number;
+    measureIndex: number;
+    octaveShiftIndex?: number;
+}
+/**
+ * Remove an octave shift direction from a measure.
+ */
+declare function removeOctaveShift(score: Score, options: RemoveOctaveShiftOptions): OperationResult<Score>;
+type BreathMarkValue = 'comma' | 'tick' | 'upbow' | 'salzedo';
+interface AddBreathMarkOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    breathMarkType?: BreathMarkValue;
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a breath mark to a note.
+ * Breath marks indicate where a performer should breathe.
+ */
+declare function addBreathMark(score: Score, options: AddBreathMarkOptions): OperationResult<Score>;
+interface RemoveBreathMarkOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}
+/**
+ * Remove a breath mark from a note.
+ */
+declare function removeBreathMark(score: Score, options: RemoveBreathMarkOptions): OperationResult<Score>;
+type CaesuraValue = 'normal' | 'thick' | 'short' | 'curved' | 'single';
+interface AddCaesuraOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+    caesuraType?: CaesuraValue;
+    placement?: 'above' | 'below';
+}
+/**
+ * Add a caesura to a note.
+ * A caesura indicates a brief, silent pause.
+ * It is notated using a "railroad tracks" symbol.
+ */
+declare function addCaesura(score: Score, options: AddCaesuraOptions): OperationResult<Score>;
+interface RemoveCaesuraOptions {
+    partIndex: number;
+    measureIndex: number;
+    noteIndex: number;
+}
+/**
+ * Remove a caesura from a note.
+ */
+declare function removeCaesura(score: Score, options: RemoveCaesuraOptions): OperationResult<Score>;
+/**
+ * Kinds of score element `setColor` can paint.
+ *
+ * `'note'` colours the `<note>` element itself, which notation programs treat
+ * as the colour of the whole note. The finer-grained targets below it colour
+ * an individual child element, which overrides the note colour for that part
+ * of the note only.
+ */
+type ColorTarget = 'note' | 'notehead' | 'stem' | 'beam' | 'accidental' | 'dot' | 'noteType' | 'notation' | 'lyric' | 'direction' | 'harmony' | 'figuredBass' | 'clef' | 'key' | 'time' | 'barline';
+/** Every `ColorTarget`, in a stable order. */
+declare const ALL_COLOR_TARGETS: readonly ColorTarget[];
+interface SetColorOptions {
+    /** Colour to apply (e.g. `"#FF0000"`), or `null` to remove it. */
+    color: Color | null;
+    /** Element kinds to paint. Defaults to `['note']`. */
+    targets?: ColorTarget[];
+    /** Restrict to these part indices. Defaults to every part. */
+    partIndices?: number[];
+    /** Restrict to these part IDs (e.g. `'P1'`). Defaults to every part. */
+    partIds?: string[];
+    /** Restrict to these measure numbers. Defaults to every measure. */
+    measureNumbers?: (string | number)[];
+    /**
+     * Only paint notes for which this returns true. Applies to the note targets
+     * (`note`, `notehead`, `stem`, `beam`, `accidental`, `dot`, `noteType`,
+     * `notation`, `lyric`); other targets are unaffected by it.
+     */
+    noteFilter?: (note: NoteEntry) => boolean;
+}
+/**
+ * Set (or clear) the colour of score elements.
+ *
+ * Returns a new Score; the input is left untouched. With no `targets` it
+ * paints the `<note>` elements, which is what "colour these notes" usually
+ * means.
+ *
+ * ```typescript
+ * // every note in measures 5-6 of the first part, red
+ * const marked = setColor(score, {
+ *   color: '#FF0000',
+ *   partIndices: [0],
+ *   measureNumbers: [5, 6],
+ * });
+ *
+ * // a single note found earlier, plus its stem and beams
+ * const one = setColor(score, {
+ *   color: '#0000FF',
+ *   targets: ['note', 'stem', 'beam'],
+ *   noteFilter: (n) => n._id === noteId,
+ * });
+ * ```
+ */
+declare function setColor(score: Score, options: SetColorOptions): Score;
+/**
+ * Remove every colour from a score — including the ones this library's
+ * targeted operations do not reach, such as part names and credit words.
+ *
+ * Returns a new Score; the input is left untouched.
+ */
+declare function clearColors(score: Score): Score;
+/**
+ * Add text to the score. Alias for addTextDirection.
+ */
+declare const addText: typeof addTextDirection;
+type AddTextOptions = AddTextDirectionOptions;
+/**
+ * Set beaming for notes. Alias for autoBeam.
+ */
+declare const setBeaming: typeof autoBeam;
+type SetBeamingOptions = AutoBeamOptions;
+/**
+ * Add a chord symbol. Alias for addHarmony.
+ */
+declare const addChordSymbol: typeof addHarmony;
+type AddChordSymbolOptions = AddHarmonyOptions;
+/**
+ * Remove a chord symbol. Alias for removeHarmony.
+ */
+declare const removeChordSymbol: typeof removeHarmony;
+type RemoveChordSymbolOptions = RemoveHarmonyOptions;
+/**
+ * Update a chord symbol. Alias for updateHarmony.
+ */
+declare const updateChordSymbol: typeof updateHarmony;
+type UpdateChordSymbolOptions = UpdateHarmonyOptions;
+/**
+ * Change the clef at a position. Alias for insertClefChange.
+ */
+declare const changeClef: typeof insertClefChange;
+type ChangeClefOptions = InsertClefChangeOptions;
+/**
+ * Set barline style. Alias for changeBarline.
+ */
+declare const setBarline: typeof changeBarline;
+type SetBarlineOptions = ChangeBarlineOptions;
+/**
+ * Add a repeat barline. Alias for addRepeatBarline.
+ */
+declare const addRepeat: typeof addRepeatBarline;
+type AddRepeatOptions = AddRepeatBarlineOptions;
+/**
+ * Remove a repeat barline. Alias for removeRepeatBarline.
+ */
+declare const removeRepeat: typeof removeRepeatBarline;
+type RemoveRepeatOptions = RemoveRepeatBarlineOptions;
+
+export { ALL_COLOR_TARGETS, type AddArticulationOptions, type AddBeamOptions, type AddBowingOptions, type AddBreathMarkOptions, type AddCaesuraOptions, type AddChordOptions, type AddChordSymbolOptions, type AddCodaOptions, type AddDynamicsOptions, type AddEndingOptions, type AddFermataOptions, type AddFingeringOptions, type AddGraceNoteOptions, type AddHarmonyOptions, type AddLyricOptions, type AddNavigationOptions, type AddOctaveShiftOptions, type AddOrnamentOptions, type AddPartOptions, type AddPedalOptions, type AddRehearsalMarkOptions, type AddRepeatBarlineOptions, type AddRepeatOptions, type AddSegnoOptions, type AddSlurOptions, type AddStringNumberOptions, type AddTempoOptions, type AddTextDirectionOptions, type AddTextOptions, type AddTieOptions, type AddVoiceOptions, type AddWedgeOptions, type AutoBeamOptions, type BarStyle, type BowingType, type BreathMarkValue, type CaesuraValue, type ChangeBarlineOptions, type ChangeClefOptions, type ChangeNoteDurationOptions, type ColorTarget, type ConvertToGraceOptions, type CopyNotesMultiMeasureOptions, type CopyNotesOptions, type CreateTupletOptions, type CutNotesOptions, type DuplicatePartOptions, type HarmonyKind, type InsertClefChangeOptions, type InsertNoteOptions, type LowerAccidentalOptions, type ModifyDynamicsOptions, type ModifyTempoOptions, type MoveNoteToStaffOptions, type MultiMeasureSelection, type NoteSelection, type OctaveShiftType, type OperationErrorCode, type OperationResult, type PasteNotesMultiMeasureOptions, type PasteNotesOptions, type RaiseAccidentalOptions, type RemoveArticulationOptions, type RemoveBeamOptions, type RemoveBowingOptions, type RemoveBreathMarkOptions, type RemoveCaesuraOptions, type RemoveChordSymbolOptions, type RemoveDynamicsOptions, type RemoveEndingOptions, type RemoveFermataOptions, type RemoveFingeringOptions, type RemoveGraceNoteOptions, type RemoveHarmonyOptions, type RemoveLyricOptions, type RemoveNoteOptions, type RemoveOctaveShiftOptions, type RemoveOrnamentOptions, type RemovePedalOptions, type RemoveRepeatBarlineOptions, type RemoveRepeatOptions, type RemoveSlurOptions, type RemoveStringNumberOptions, type RemoveTempoOptions, type RemoveTieOptions, type RemoveTupletOptions, type RemoveWedgeOptions, type SetBarlineOptions, type SetBeamingOptions, type SetColorOptions, type SetNotePitchBySemitoneOptions, type SetNotePitchOptions, type SetStavesOptions, type ShiftNotePitchOptions, type StopOctaveShiftOptions, type UpdateChordSymbolOptions, type UpdateHarmonyOptions, type UpdateLyricOptions, ValidationError, addArticulation, addBeam, addBowing, addBreathMark, addCaesura, addChord, addChordNote, addChordNoteChecked, addChordSymbol, addCoda, addDaCapo, addDalSegno, addDynamics, addEnding, addFermata, addFine, addFingering, addGraceNote, addHarmony, addLyric, addNote, addNoteChecked, addOctaveShift, addOrnament, addPart, addPedal, addRehearsalMark, addRepeat, addRepeatBarline, addSegno, addSlur, addStringNumber, addTempo, addText, addTextDirection, addTie, addToCoda, addVoice, addWedge, autoBeam, changeBarline, changeClef, changeKey, changeNoteDuration, changeTime, clearColors, convertToGrace, copyNotes, copyNotesMultiMeasure, createTuplet, cutNotes, deleteMeasure, deleteNote, deleteNoteChecked, duplicatePart, insertClefChange, insertMeasure, insertNote, lowerAccidental, modifyDynamics, modifyNoteDuration, modifyNoteDurationChecked, modifyNotePitch, modifyNotePitchChecked, modifyTempo, moveNoteToStaff, pasteNotes, pasteNotesMultiMeasure, raiseAccidental, removeArticulation, removeBeam, removeBowing, removeBreathMark, removeCaesura, removeChordSymbol, removeDynamics, removeEnding, removeFermata, removeFingering, removeGraceNote, removeHarmony, removeLyric, removeNote, removeOctaveShift, removeOrnament, removePart, removePedal, removeRepeat, removeRepeatBarline, removeSlur, removeStringNumber, removeTempo, removeTie, removeTuplet, removeWedge, setBarline, setBeaming, setColor, setNotePitch, setNotePitchBySemitone, setStaves, shiftNotePitch, stopOctaveShift, transpose, transposeChecked, updateChordSymbol, updateHarmony, updateLyric };