interface Score {
    _id: string;
    metadata: ScoreMetadata;
    partList: PartListEntry[];
    parts: Part[];
    defaults?: Defaults;
    credits?: Credit[];
    version?: string;
}
interface ScoreMetadata {
    workTitle?: string;
    workNumber?: string;
    movementTitle?: string;
    movementNumber?: string;
    creators?: Creator[];
    rights?: string[];
    encoding?: Encoding;
    source?: string;
    miscellaneous?: MiscellaneousField[];
}
interface Creator {
    type?: string;
    value: string;
}
interface Encoding {
    software?: string[];
    encodingDate?: string;
    encoder?: string[];
    encodingDescription?: string;
    supports?: Support[];
}
interface Support {
    element: string;
    type: 'yes' | 'no';
    attribute?: string;
    value?: string;
}
interface MiscellaneousField {
    name: string;
    value: string;
}
interface Defaults {
    scaling?: {
        millimeters: number;
        tenths: number;
    };
    pageLayout?: PageLayout;
    systemLayout?: SystemLayout;
    staffLayout?: {
        number?: number;
        staffDistance?: number;
    }[];
    appearance?: Record<string, unknown>;
    musicFont?: FontInfo;
    wordFont?: FontInfo;
    lyricFont?: LyricFontInfo[];
    lyricLanguage?: LyricLanguageInfo[];
}
interface LyricFontInfo extends FontInfo {
    number?: number;
    name?: string;
}
interface LyricLanguageInfo {
    number?: number;
    name?: string;
    xmlLang: string;
}
interface PageLayout {
    pageHeight?: number;
    pageWidth?: number;
    pageMargins?: PageMargins[];
}
interface PageMargins {
    type?: 'odd' | 'even' | 'both';
    leftMargin?: number;
    rightMargin?: number;
    topMargin?: number;
    bottomMargin?: number;
    leftMarginRaw?: string;
    rightMarginRaw?: string;
    topMarginRaw?: string;
    bottomMarginRaw?: string;
}
interface SystemLayout {
    systemMargins?: {
        leftMargin?: number;
        rightMargin?: number;
        leftMarginRaw?: string;
        rightMarginRaw?: string;
    };
    systemDistance?: number;
    systemDistanceRaw?: string;
    topSystemDistance?: number;
    topSystemDistanceRaw?: string;
    systemDividers?: {
        leftDivider?: {
            printObject?: boolean;
            halign?: string;
            valign?: string;
        };
        rightDivider?: {
            printObject?: boolean;
            halign?: string;
            valign?: string;
        };
    };
}
interface FontInfo {
    fontFamily?: string;
    fontSize?: string;
    fontStyle?: string;
    fontWeight?: string;
}
interface Credit {
    _id: string;
    page?: number;
    creditType?: string[];
    creditWords?: CreditWords[];
    creditImage?: {
        source: string;
        type: string;
        height?: number;
        width?: number;
    };
}
interface CreditWords {
    text: string;
    defaultX?: number;
    defaultY?: number;
    fontFamily?: string;
    fontSize?: string;
    fontWeight?: string;
    fontStyle?: string;
    justify?: string;
    halign?: string;
    valign?: string;
    letterSpacing?: string;
    xmlLang?: string;
    xmlSpace?: string;
}
type PartListEntry = PartInfo | PartGroup;
interface PartInfo {
    _id: string;
    type: 'score-part';
    id: string;
    name?: string;
    namePrintObject?: boolean;
    partNameDisplay?: DisplayText[];
    abbreviation?: string;
    abbreviationPrintObject?: boolean;
    partAbbreviationDisplay?: DisplayText[];
    scoreInstruments?: ScoreInstrument[];
    midiDevices?: MidiDevice[];
    midiInstruments?: MidiInstrument[];
    groups?: string[];
}
interface DisplayText {
    text: string;
    fontFamily?: string;
    fontSize?: string;
    fontStyle?: string;
    fontWeight?: string;
    xmlSpace?: string;
}
interface ScoreInstrument {
    id: string;
    name: string;
    abbreviation?: string;
    sound?: string;
    solo?: boolean;
    ensemble?: number;
}
interface MidiDevice {
    id?: string;
    port?: number;
}
interface MidiInstrument {
    id: string;
    channel?: number;
    name?: string;
    bank?: number;
    program?: number;
    unpitched?: number;
    volume?: number;
    pan?: number;
    elevation?: number;
}
interface PartGroup {
    _id: string;
    type: 'part-group';
    groupType: 'start' | 'stop';
    number?: number;
    groupName?: string;
    groupNameDisplay?: DisplayText[];
    groupAbbreviation?: string;
    groupAbbreviationDisplay?: DisplayText[];
    groupSymbol?: 'none' | 'brace' | 'line' | 'bracket' | 'square';
    groupSymbolDefaultX?: number;
    groupBarline?: 'yes' | 'no' | 'Mensurstrich';
}
interface Part {
    _id: string;
    id: string;
    measures: Measure[];
}
interface Measure {
    _id: string;
    number: string;
    width?: number;
    implicit?: boolean;
    attributes?: MeasureAttributes;
    entries: MeasureEntry[];
    barlines?: Barline[];
    print?: Print;
}
interface Print {
    newSystem?: boolean;
    newPage?: boolean;
    blankPage?: number;
    pageNumber?: string;
    systemLayout?: SystemLayout;
    pageLayout?: PageLayout;
    staffLayouts?: {
        number?: number;
        staffDistance?: number;
    }[];
    measureLayout?: {
        measureDistance?: number;
    };
    measureNumbering?: MeasureNumbering;
    partNameDisplay?: DisplayText[];
    partAbbreviationDisplay?: DisplayText[];
}
interface MeasureNumbering {
    value: string;
    system?: 'only-top' | 'only-bottom' | 'all-system-parts' | 'none';
}
interface MeasureAttributes {
    _id?: string;
    divisions?: number;
    time?: TimeSignature;
    times?: TimeSignature[];
    key?: KeySignature;
    keys?: KeySignature[];
    clef?: Clef[];
    staves?: number;
    instruments?: number;
    transpose?: Transpose;
    transposes?: Transpose[];
    staffDetails?: StaffDetails[];
    measureStyle?: MeasureStyle[];
}
interface StaffDetails {
    number?: number;
    staffType?: 'ossia' | 'cue' | 'editorial' | 'regular' | 'alternate';
    staffLines?: number;
    staffTuning?: StaffTuning[];
    capo?: number;
    staffSize?: number;
    staffSizeScaling?: number;
    showFrets?: 'numbers' | 'letters';
    printObject?: boolean;
    printSpacing?: boolean;
}
interface StaffTuning {
    line: number;
    tuningStep: string;
    tuningOctave: number;
    tuningAlter?: number;
}
interface MeasureStyle {
    number?: number;
    multipleRest?: number;
    measureRepeat?: {
        type: 'start' | 'stop';
        slashes?: number;
    };
    beatRepeat?: {
        type: 'start' | 'stop';
        slashes?: number;
    };
    slash?: {
        type: 'start' | 'stop';
        useDots?: boolean;
        useStems?: boolean;
    };
}
interface TimeSignature {
    beats: string;
    beatType: number;
    beatsList?: number[];
    beatsStrList?: string[];
    beatTypeList?: number[];
    symbol?: 'common' | 'cut' | 'single-number' | 'note' | 'dotted-note' | 'normal';
    printObject?: boolean;
    senzaMisura?: boolean;
}
interface KeySignature {
    fifths: number;
    mode?: 'major' | 'minor' | 'dorian' | 'phrygian' | 'lydian' | 'mixolydian' | 'aeolian' | 'ionian' | 'locrian' | 'none';
    cancel?: number;
    cancelLocation?: 'left' | 'right' | 'before-barline';
    number?: number;
    printObject?: boolean;
    keySteps?: string[];
    keyAlters?: number[];
    keyOctaves?: KeyOctave[];
}
interface KeyOctave {
    number: number;
    octave: number;
    cancel?: boolean;
}
interface Clef {
    sign: 'G' | 'F' | 'C' | 'percussion' | 'TAB';
    line?: number;
    staff?: number;
    clefOctaveChange?: number;
    printObject?: boolean;
    afterBarline?: boolean;
}
interface Transpose {
    diatonic: number;
    chromatic: number;
    octaveChange?: number;
}
interface Barline {
    _id: string;
    location: 'left' | 'right' | 'middle';
    barStyle?: 'regular' | 'dotted' | 'dashed' | 'heavy' | 'light-light' | 'light-heavy' | 'heavy-light' | 'heavy-heavy' | 'tick' | 'short' | 'none';
    repeat?: {
        direction: 'forward' | 'backward';
        times?: number;
        winged?: string;
    };
    ending?: {
        number: string;
        type: 'start' | 'stop' | 'discontinue';
        text?: string;
        defaultY?: number;
        endLength?: number;
    };
}
type MeasureEntry = NoteEntry | BackupEntry | ForwardEntry | DirectionEntry | HarmonyEntry | FiguredBassEntry | SoundEntry | AttributesEntry | GroupingEntry;
interface AttributesEntry {
    _id: string;
    type: 'attributes';
    attributes: MeasureAttributes;
}
interface NoteEntry {
    _id: string;
    type: 'note';
    pitch?: Pitch;
    rest?: RestInfo;
    unpitched?: {
        displayStep?: string;
        displayOctave?: number;
    };
    duration: number;
    voice?: string;
    staff?: number;
    chord?: boolean;
    cue?: boolean;
    instrument?: string;
    dynamics?: number;
    printObject?: boolean;
    printSpacing?: boolean;
    printDot?: boolean;
    defaultX?: number;
    defaultY?: number;
    relativeX?: number;
    relativeY?: number;
    noteType?: NoteType;
    noteTypeSize?: string;
    dots?: number;
    accidental?: AccidentalInfo;
    stem?: StemInfo;
    notehead?: NoteheadInfo;
    noteheadText?: string;
    tie?: TieInfo;
    ties?: TieInfo[];
    beam?: BeamInfo[];
    notations?: Notation[];
    lyrics?: Lyric[];
    grace?: {
        slash?: boolean;
        stealTimePrevious?: number;
        stealTimeFollowing?: number;
    };
    timeModification?: {
        actualNotes: number;
        normalNotes: number;
        normalType?: NoteType;
        normalDots?: number;
    };
}
interface BackupEntry {
    _id: string;
    type: 'backup';
    duration: number;
}
interface ForwardEntry {
    _id: string;
    type: 'forward';
    duration: number;
    voice?: string;
    staff?: number;
}
interface DirectionSound {
    tempo?: number;
    dynamics?: number;
    midiInstrument?: {
        id: string;
        midiProgram?: number;
        midiChannel?: number;
        volume?: number;
        pan?: number;
    };
    damperPedal?: 'yes' | 'no';
    softPedal?: 'yes' | 'no';
    sostenutoPedal?: 'yes' | 'no';
}
interface DirectionEntry {
    _id: string;
    type: 'direction';
    directionTypes: DirectionType[];
    placement?: 'above' | 'below';
    directive?: boolean;
    staff?: number;
    voice?: string;
    offset?: number;
    offsetSound?: boolean;
    sound?: DirectionSound;
    system?: 'only-top' | 'also-top' | 'none';
}
interface Swing {
    straight?: boolean;
    first?: number;
    second?: number;
    swingType?: string;
}
interface SoundEntry {
    _id: string;
    type: 'sound';
    tempo?: number;
    dynamics?: number;
    dacapo?: boolean;
    segno?: string;
    dalsegno?: string;
    coda?: string;
    tocoda?: string;
    fine?: boolean;
    forwardRepeat?: boolean;
    swing?: Swing;
    damperPedal?: boolean | 'yes' | 'no';
    softPedal?: boolean | 'yes' | 'no';
    sostenutoPedal?: boolean | 'yes' | 'no';
}
interface GroupingEntry {
    _id: string;
    type: 'grouping';
    groupingType: 'start' | 'stop' | 'single';
    number?: string;
}
interface HarmonyEntry {
    _id: string;
    type: 'harmony';
    root: {
        rootStep: string;
        rootAlter?: number;
    };
    kind: string;
    kindText?: string;
    kindHalign?: string;
    bass?: {
        bassStep: string;
        bassAlter?: number;
        arrangement?: string;
    };
    inversion?: number;
    degrees?: HarmonyDegree[];
    frame?: HarmonyFrame;
    staff?: number;
    placement?: 'above' | 'below';
    offset?: number;
    printFrame?: boolean;
    defaultY?: number;
    fontSize?: string;
    halign?: string;
}
interface HarmonyDegree {
    degreeValue: number;
    degreeAlter?: number;
    degreeType: 'add' | 'alter' | 'subtract';
}
interface HarmonyFrame {
    frameStrings?: number;
    frameFrets?: number;
    firstFret?: number;
    firstFretText?: string;
    firstFretLocation?: 'left' | 'right';
    frameNotes?: FrameNote[];
}
interface FrameNote {
    string: number;
    fret: number;
    fingering?: string;
    barre?: 'start' | 'stop';
}
interface FiguredBassEntry {
    _id: string;
    type: 'figured-bass';
    figures: Figure[];
    duration?: number;
    parentheses?: boolean;
}
interface Figure {
    figureNumber?: string;
    prefix?: string;
    suffix?: string;
    extend?: boolean | {
        type?: 'start' | 'stop' | 'continue';
    };
}
interface Pitch {
    step: 'C' | 'D' | 'E' | 'F' | 'G' | 'A' | 'B';
    octave: number;
    alter?: number;
}
interface RestInfo {
    measure?: boolean;
    displayStep?: string;
    displayOctave?: number;
}
type NoteType = 'maxima' | 'long' | 'breve' | 'whole' | 'half' | 'quarter' | 'eighth' | '16th' | '32nd' | '64th' | '128th' | '256th' | '512th' | '1024th';
type Accidental = 'sharp' | 'natural' | 'flat' | 'double-sharp' | 'double-flat' | 'sharp-sharp' | 'flat-flat' | 'natural-sharp' | 'natural-flat' | 'quarter-flat' | 'quarter-sharp' | 'three-quarters-flat' | 'three-quarters-sharp' | 'sharp-down' | 'sharp-up' | 'natural-down' | 'natural-up' | 'flat-down' | 'flat-up' | 'double-sharp-down' | 'double-sharp-up' | 'flat-flat-down' | 'flat-flat-up' | 'arrow-down' | 'arrow-up' | 'triple-sharp' | 'triple-flat' | 'slash-quarter-sharp' | 'slash-sharp' | 'slash-flat' | 'double-slash-flat' | 'sharp-1' | 'sharp-2' | 'sharp-3' | 'sharp-5' | 'flat-1' | 'flat-2' | 'flat-3' | 'flat-4' | 'sori' | 'koron' | 'other';
interface AccidentalInfo {
    value: Accidental;
    cautionary?: boolean;
    editorial?: boolean;
    parentheses?: boolean;
    bracket?: boolean;
    relativeX?: number;
    relativeY?: number;
    color?: string;
    size?: string;
    fontSize?: string;
}
interface NoteheadInfo {
    value: NoteheadValue;
    filled?: boolean;
    parentheses?: boolean;
}
interface StemInfo {
    value: 'up' | 'down' | 'none' | 'double';
    defaultX?: number;
    defaultY?: number;
}
type NoteheadValue = 'slash' | 'triangle' | 'diamond' | 'square' | 'cross' | 'x' | 'circle-x' | 'inverted triangle' | 'arrow down' | 'arrow up' | 'circled' | 'slashed' | 'back slashed' | 'normal' | 'cluster' | 'circle dot' | 'left triangle' | 'rectangle' | 'none' | 'do' | 're' | 'mi' | 'fa' | 'fa up' | 'so' | 'la' | 'ti' | 'other';
interface TieInfo {
    type: 'start' | 'stop' | 'continue';
}
interface BeamInfo {
    number: number;
    type: 'begin' | 'continue' | 'end' | 'forward hook' | 'backward hook';
}
type Notation = ArticulationNotation | OrnamentNotation | TechnicalNotation | SlurNotation | TiedNotation | TupletNotation | DynamicsNotation | FermataNotation | ArpeggiateNotation | NonArpeggiateNotation | AccidentalMarkNotation | GlissandoNotation | SlideNotation | OtherNotation;
interface BaseNotation {
    placement?: 'above' | 'below';
    notationsIndex?: number;
    articulationsIndex?: number;
}
interface ArticulationNotation extends BaseNotation {
    type: 'articulation';
    articulation: ArticulationType;
    strongAccentType?: 'up' | 'down';
    defaultX?: number;
    defaultY?: number;
}
type ArticulationType = 'accent' | 'strong-accent' | 'staccato' | 'staccatissimo' | 'tenuto' | 'detached-legato' | 'marcato' | 'spiccato' | 'scoop' | 'plop' | 'doit' | 'falloff' | 'breath-mark' | 'caesura' | 'stress' | 'unstress' | 'soft-accent';
interface AccidentalMarkInfo {
    value: Accidental;
    placement?: 'above' | 'below';
}
interface OrnamentNotation extends BaseNotation {
    type: 'ornament';
    ornament: OrnamentType;
    accidentalMark?: Accidental;
    accidentalMarks?: AccidentalMarkInfo[];
    wavyLineType?: 'start' | 'stop' | 'continue';
    number?: number;
    tremoloMarks?: number;
    tremoloType?: 'start' | 'stop' | 'single' | 'unmeasured';
    defaultX?: number;
    defaultY?: number;
}
type OrnamentType = 'trill-mark' | 'mordent' | 'inverted-mordent' | 'turn' | 'inverted-turn' | 'delayed-turn' | 'delayed-inverted-turn' | 'vertical-turn' | 'inverted-vertical-turn' | 'shake' | 'wavy-line' | 'schleifer' | 'tremolo' | 'haydn' | 'other-ornament' | 'empty';
interface TechnicalNotation extends BaseNotation {
    type: 'technical';
    technical: TechnicalType;
    string?: number;
    fret?: number;
    fingering?: string;
    fingeringSubstitution?: boolean;
    fingeringAlternate?: boolean;
    text?: string;
    bendAlter?: number;
    preBend?: boolean;
    release?: boolean;
    withBar?: boolean;
    harmonicNatural?: boolean;
    harmonicArtificial?: boolean;
    basePitch?: boolean;
    touchingPitch?: boolean;
    soundingPitch?: boolean;
    startStop?: 'start' | 'stop';
    number?: number;
    substitution?: boolean;
    defaultX?: number;
    defaultY?: number;
}
type TechnicalType = 'up-bow' | 'down-bow' | 'harmonic' | 'open-string' | 'thumb-position' | 'fingering' | 'pluck' | 'double-tongue' | 'triple-tongue' | 'stopped' | 'snap-pizzicato' | 'fret' | 'string' | 'hammer-on' | 'pull-off' | 'bend' | 'tap' | 'heel' | 'toe' | 'fingernails' | 'hole' | 'arrow' | 'handbell' | 'brass-bend' | 'flip' | 'smear' | 'open' | 'half-muted' | 'harmon-mute' | 'golpe' | 'other-technical';
interface SlurNotation extends BaseNotation {
    type: 'slur';
    slurType: 'start' | 'stop' | 'continue';
    number?: number;
    lineType?: 'solid' | 'dashed' | 'dotted' | 'wavy';
    orientation?: 'over' | 'under';
    defaultX?: number;
    defaultY?: number;
    bezierX?: number;
    bezierY?: number;
    bezierX2?: number;
    bezierY2?: number;
}
interface TiedNotation extends BaseNotation {
    type: 'tied';
    tiedType: 'start' | 'stop' | 'continue' | 'let-ring';
    number?: number;
    orientation?: 'over' | 'under';
}
interface TupletNotation extends BaseNotation {
    type: 'tuplet';
    tupletType: 'start' | 'stop';
    number?: number;
    bracket?: boolean;
    showNumber?: 'actual' | 'both' | 'none';
    showType?: 'actual' | 'both' | 'none';
    lineShape?: 'straight' | 'curved';
    tupletActual?: {
        tupletNumber?: number;
        tupletType?: NoteType;
        tupletDots?: number;
    };
    tupletNormal?: {
        tupletNumber?: number;
        tupletType?: NoteType;
        tupletDots?: number;
    };
}
interface DynamicsNotation extends BaseNotation {
    type: 'dynamics';
    dynamics: DynamicsValue[];
    otherDynamics?: string;
}
interface FermataNotation extends BaseNotation {
    type: 'fermata';
    shape?: 'normal' | 'angled' | 'square' | 'double-angled' | 'double-square' | 'double-dot' | 'half-curve' | 'curlew';
    fermataType?: 'upright' | 'inverted';
    defaultX?: number;
    defaultY?: number;
}
interface ArpeggiateNotation extends BaseNotation {
    type: 'arpeggiate';
    direction?: 'up' | 'down';
    number?: number;
    defaultX?: number;
    defaultY?: number;
}
interface NonArpeggiateNotation extends BaseNotation {
    type: 'non-arpeggiate';
    nonArpeggiateType: 'top' | 'bottom';
    number?: number;
}
interface AccidentalMarkNotation extends BaseNotation {
    type: 'accidental-mark';
    value: string;
}
interface GlissandoNotation extends BaseNotation {
    type: 'glissando';
    glissandoType: 'start' | 'stop';
    number?: number;
    lineType?: 'solid' | 'dashed' | 'dotted' | 'wavy';
    text?: string;
}
interface SlideNotation extends BaseNotation {
    type: 'slide';
    slideType: 'start' | 'stop';
    number?: number;
    lineType?: 'solid' | 'dashed' | 'dotted' | 'wavy';
    text?: string;
}
interface OtherNotation extends BaseNotation {
    type: 'other-notation';
    name: string;
    text?: string;
}
type DirectionType = {
    kind: 'dynamics';
    value?: DynamicsValue;
    otherDynamics?: string;
    defaultX?: number;
    defaultY?: number;
    relativeX?: number;
    halign?: string;
} | {
    kind: 'wedge';
    type: 'crescendo' | 'diminuendo' | 'stop';
    spread?: number;
    defaultY?: number;
    relativeX?: number;
} | {
    kind: 'metronome';
    beatUnit: NoteType;
    perMinute?: number | string;
    beatUnitDot?: boolean;
    beatUnit2?: NoteType;
    beatUnitDot2?: boolean;
    parentheses?: boolean;
    printObject?: boolean;
    defaultY?: number;
    fontFamily?: string;
    fontSize?: string;
} | {
    kind: 'words';
    text: string;
    defaultX?: number;
    defaultY?: number;
    relativeX?: number;
    relativeY?: number;
    fontFamily?: string;
    fontSize?: string;
    fontStyle?: string;
    fontWeight?: string;
    xmlLang?: string;
    justify?: string;
    color?: string;
    xmlSpace?: string;
    halign?: string;
} | {
    kind: 'rehearsal';
    text: string;
    enclosure?: string;
    defaultX?: number;
    defaultY?: number;
    fontSize?: string;
    fontWeight?: string;
} | {
    kind: 'segno';
} | {
    kind: 'coda';
} | {
    kind: 'pedal';
    type: 'start' | 'stop' | 'change' | 'continue';
    line?: boolean;
    defaultY?: number;
    relativeX?: number;
    halign?: string;
} | {
    kind: 'octave-shift';
    type: 'up' | 'down' | 'stop';
    size?: number;
} | {
    kind: 'bracket';
    type: 'start' | 'stop' | 'continue';
    number?: number;
    lineEnd?: 'up' | 'down' | 'both' | 'arrow' | 'none';
    lineType?: 'solid' | 'dashed' | 'dotted' | 'wavy';
    defaultY?: number;
    relativeX?: number;
} | {
    kind: 'dashes';
    type: 'start' | 'stop' | 'continue';
    number?: number;
    dashLength?: number;
    defaultY?: number;
    spaceLength?: number;
} | {
    kind: 'accordion-registration';
    high?: boolean;
    middle?: number | string;
    middlePresent?: boolean;
    low?: boolean;
} | {
    kind: 'swing';
    straight?: boolean;
    first?: number;
    second?: number;
    swingType?: NoteType;
} | {
    kind: 'eyeglasses';
} | {
    kind: 'damp';
} | {
    kind: 'damp-all';
} | {
    kind: 'scordatura';
    accords?: Accord[];
} | {
    kind: 'harp-pedals';
    pedalTunings?: PedalTuning[];
} | {
    kind: 'image';
    source?: string;
    type?: string;
} | {
    kind: 'other-direction';
    text: string;
    defaultX?: number;
    defaultY?: number;
    halign?: string;
    printObject?: boolean;
};
interface Accord {
    string: number;
    tuningStep: string;
    tuningAlter?: number;
    tuningOctave: number;
}
interface PedalTuning {
    pedalStep: string;
    pedalAlter: number;
}
type DynamicsValue = 'pppppp' | 'ppppp' | 'pppp' | 'ppp' | 'pp' | 'p' | 'mp' | 'mf' | 'f' | 'ff' | 'fff' | 'ffff' | 'fffff' | 'ffffff' | 'sf' | 'sfz' | 'sffz' | 'sfp' | 'sfpp' | 'fp' | 'rf' | 'rfz' | 'fz' | 'n' | 'pf';
interface LyricTextElement {
    text: string;
    syllabic?: 'single' | 'begin' | 'middle' | 'end';
}
interface Lyric {
    number?: number;
    name?: string;
    syllabic?: 'single' | 'begin' | 'middle' | 'end';
    text: string;
    textElements?: LyricTextElement[];
    elision?: boolean;
    extend?: boolean | {
        type?: 'start' | 'stop' | 'continue';
    };
    endLine?: boolean;
    endParagraph?: boolean;
    defaultY?: number;
    relativeX?: number;
    justify?: string;
    placement?: 'above' | 'below';
}
interface VoiceGroup {
    staff: number;
    voice: string;
    notes: NoteEntry[];
}
interface StaffGroup {
    staff: number;
    notes: NoteEntry[];
}
interface NoteWithPosition extends NoteEntry {
    absolutePosition: number;
}
interface Chord {
    position: number;
    duration: number;
    notes: NoteEntry[];
}
interface NoteIteratorItem {
    part: Part;
    measure: Measure;
    note: NoteEntry;
    position: number;
}
/**
 * Voice to Staff mapping for inferring staff when not explicitly specified
 */
interface VoiceToStaffMap {
    get(voice: string): number | undefined;
    has(voice: string): boolean;
    entries(): IterableIterator<[string, number]>;
    size: number;
}
/**
 * Note with full context information
 */
interface NoteWithContext {
    note: NoteEntry;
    part: Part;
    partIndex: number;
    measure: Measure;
    measureIndex: number;
    position: number;
}
/**
 * Entry with context (for iterateEntries)
 */
interface EntryWithContext {
    entry: MeasureEntry;
    part: Part;
    partIndex: number;
    measure: Measure;
    measureIndex: number;
    position: number;
}
/**
 * Direction with context information
 */
interface DirectionWithContext {
    direction: DirectionEntry;
    part: Part;
    partIndex: number;
    measure: Measure;
    measureIndex: number;
    position: number;
}
/**
 * Staff range (min and max staff numbers)
 */
interface StaffRange {
    min: number;
    max: number;
}
/**
 * Options for position-based queries
 */
interface PositionQueryOptions {
    staff?: number;
    voice?: string;
    includeChordNotes?: boolean;
}
/**
 * Vertical slice - all notes at a specific position across all parts
 */
interface VerticalSlice {
    measureIndex: number;
    position: number;
    parts: Map<number, NoteEntry[]>;
}
/**
 * Voice line - continuous melodic line across measures
 */
interface VoiceLine {
    partIndex: number;
    voice: string;
    staff?: number;
    notes: NoteWithContext[];
}
/**
 * Adjacent notes (previous and next)
 */
interface AdjacentNotes {
    prev: NoteWithContext | null;
    next: NoteWithContext | null;
}
/**
 * Direction kind type for filtering
 */
type DirectionKind = DirectionType['kind'];
/**
 * Dynamic marking with context
 */
interface DynamicWithContext {
    dynamic?: DynamicsValue;
    otherDynamics?: string;
    direction: DirectionEntry;
    part: Part;
    partIndex: number;
    measure: Measure;
    measureIndex: number;
    position: number;
}
/**
 * Tempo marking with context
 */
interface TempoWithContext {
    beatUnit: NoteType;
    perMinute?: number | string;
    beatUnitDot?: boolean;
    direction: DirectionEntry;
    partIndex: number;
    measureIndex: number;
    position: number;
}
/**
 * Pedal marking with context
 */
interface PedalWithContext {
    pedalType: 'start' | 'stop' | 'change' | 'continue';
    direction: DirectionEntry;
    partIndex: number;
    measureIndex: number;
    position: number;
}
/**
 * Wedge (crescendo/diminuendo) with context
 */
interface WedgeWithContext {
    wedgeType: 'crescendo' | 'diminuendo' | 'stop';
    direction: DirectionEntry;
    partIndex: number;
    measureIndex: number;
    position: number;
}
/**
 * Octave shift with context
 */
interface OctaveShiftWithContext {
    shiftType: 'up' | 'down' | 'stop';
    size?: number;
    direction: DirectionEntry;
    partIndex: number;
    measureIndex: number;
    position: number;
}
/**
 * A group of tied notes (notes connected by ties)
 */
interface TiedNoteGroup {
    notes: NoteWithContext[];
    /** Total duration of all tied notes */
    totalDuration: number;
}
/**
 * A slur span from start to stop
 */
interface SlurSpan {
    number: number;
    startNote: NoteWithContext;
    endNote: NoteWithContext;
    /** Notes covered by the slur (including start and end) */
    notes: NoteWithContext[];
}
/**
 * A tuplet group
 */
interface TupletGroup {
    number: number;
    notes: NoteWithContext[];
    /** Actual notes (numerator of time modification) */
    actualNotes: number;
    /** Normal notes (denominator of time modification) */
    normalNotes: number;
}
/**
 * A beam group (notes connected by beams)
 */
interface BeamGroup {
    notes: NoteWithContext[];
    /** Beam level (1 for eighth notes, 2 for sixteenth, etc.) */
    beamLevel: number;
}
/**
 * Filter for finding notes with specific notations
 */
type NotationType = Notation['type'];
/**
 * Harmony entry with context
 */
interface HarmonyWithContext {
    harmony: HarmonyEntry;
    part: Part;
    partIndex: number;
    measure: Measure;
    measureIndex: number;
    position: number;
}
/**
 * Lyric entry with context
 */
interface LyricWithContext {
    lyric: Lyric;
    note: NoteEntry;
    part: Part;
    partIndex: number;
    measure: Measure;
    measureIndex: number;
    position: number;
    verse: number;
}
/**
 * Assembled lyrics for a verse
 */
interface AssembledLyrics {
    verse: number;
    text: string;
    syllables: {
        text: string;
        position: number;
        measureIndex: number;
    }[];
}
/**
 * Barline information with context
 */
interface BarlineWithContext {
    barline: Barline;
    partIndex: number;
    measureIndex: number;
    measureNumber: string;
}
/**
 * Repeat structure information
 */
interface RepeatInfo {
    type: 'forward' | 'backward';
    times?: number;
    measureIndex: number;
    measureNumber: string;
}
/**
 * Ending (volta bracket) information
 */
interface EndingInfo {
    number: string;
    type: 'start' | 'stop' | 'discontinue';
    partIndex: number;
    measureIndex: number;
    measureNumber: string;
}
/**
 * Key change information
 */
interface KeyChangeInfo {
    key: KeySignature;
    partIndex: number;
    measureIndex: number;
    measureNumber: string;
    position: number;
}
/**
 * Time signature change information
 */
interface TimeChangeInfo {
    time: TimeSignature;
    partIndex: number;
    measureIndex: number;
    measureNumber: string;
}
/**
 * Clef change information
 */
interface ClefChangeInfo {
    clef: Clef;
    staff: number;
    partIndex: number;
    measureIndex: number;
    measureNumber: string;
    position: number;
}
/**
 * All structural changes combined
 */
interface StructuralChanges {
    keyChanges: KeyChangeInfo[];
    timeChanges: TimeChangeInfo[];
    clefChanges: ClefChangeInfo[];
}

export type { TupletGroup as $, Accidental as A, BackupEntry as B, Clef as C, DirectionType as D, EntryWithContext as E, ForwardEntry as F, StaffRange as G, PositionQueryOptions as H, VerticalSlice as I, VoiceLine as J, KeySignature as K, Lyric as L, Measure as M, NoteEntry as N, AdjacentNotes as O, Pitch as P, DirectionKind as Q, DynamicWithContext as R, Score as S, TieInfo as T, TempoWithContext as U, VoiceGroup as V, PedalWithContext as W, WedgeWithContext as X, OctaveShiftWithContext as Y, TiedNoteGroup as Z, SlurSpan as _, DirectionEntry as a, BeamGroup as a0, NotationType as a1, HarmonyWithContext as a2, LyricWithContext as a3, AssembledLyrics as a4, BarlineWithContext as a5, RepeatInfo as a6, EndingInfo as a7, KeyChangeInfo as a8, TimeChangeInfo as a9, ClefChangeInfo as aa, StructuralChanges as ab, ArticulationType as ac, OrnamentType as ad, HarmonyEntry as ae, PartListEntry as b, PartInfo as c, ScoreMetadata as d, PartGroup as e, Part as f, MeasureAttributes as g, MeasureEntry as h, NoteType as i, AccidentalInfo as j, BeamInfo as k, Notation as l, DynamicsValue as m, TimeSignature as n, Transpose as o, Barline as p, StaffGroup as q, NoteWithPosition as r, Chord as s, NoteIteratorItem as t, Print as u, Defaults as v, Credit as w, VoiceToStaffMap as x, NoteWithContext as y, DirectionWithContext as z };